Initial source drop of OpenACC implementation

    Dmitry Bocharnikov <dmitry.b@samsung.com>
    Evgeny Gavrin <e.gavrin@samsung.com>
    Ilmir Usmanov <i.usmanov@samsung.com>

    * liboacc/*: Add runtime library for OpenACC.
    * gcc/Makefile.in: Likewise.
    * gcc/oacc-builtins.def: Add builtins for ACC.
    * gcc/gimple-opencl.c: Add OpenCL generation.
    * gcc/gimple-opencl.h: Likewise.
    * gcc/oacc-low.c: Add OpenACC lowering pass.
    * gcc/gimple-low.c: Likewise.
    * gcc/builtin-types.def: Add support of OpenACC.
    * gcc/gsstruct.def: Likewise.
    * gcc/tree.def: Likewise.
    * gcc/treestruct.def: Likewise.
    * gcc/tree-cfg.c: Likewise.
    * gcc/tree-core.h: Likewise.
    * gcc/cp/cp-tree.h: Likewise.
    * gcc/cp/decl.c: Likewise.
    * gcc/cp/semantics.c: Likewise.
    * gcc/cp/parser.c: Likewise.
    * gcc/cp/parser.h: Likewise.
    * gcc/cp/name-lookup.c: Likewise.
    * gcc/cp/name-lookup.h: Likewise.
    * gcc/tree-pass.h: Likewise.
    * gcc/gimple.def: Likewise.
    * gcc/testsuite/gfortran.dg/gacc: Add Fortran tests
    * gcc/passes.def: Add OpenACC passes.
    * gcc/tree-pretty-print.c: Add some pp funcs.
    * gcc/tree-pretty-print.h: Likewise.
    * gcc/builtins.def: Add builtins for OpenACC.
    * gcc/fortran/*: Add ACC support for Fortran.
    * gcc/fortran/gfortran.h: Likewise.
    * gcc/fortran/lang.opt: Likewise..
    * gcc/fortran/trans-stmt.h: Likewise.
    * gcc/fortran/scanner.c: Likewise.
    * gcc/fortran/trans-openacc.c: Likewise.
    * gcc/fortran/resolve.c: Likewise.
    * gcc/fortran/f95-lang.c: Likewise.
    * gcc/fortran/match.c: Likewise.
    * gcc/fortran/match.h: Likewise.
    * gcc/fortran/types.def: Likewise.
    * gcc/fortran/decl.c: Likewise.
    * gcc/fortran/openacc.c: Likewise.
    * gcc/fortran/dump-parse-tree.c: Likewise.
    * gcc/fortran/Make-lang.in: Likewise.
    * gcc/fortran/trans.c: Likewise.
    * gcc/fortran/st.c: Likewise.
    * gcc/fortran/parse.c: Likewise.
    * gcc/fortran/parse.h: Likewise.
    * gcc/fortran/options.c: Likewise.
    * gcc/gimplify.c: Add gimplification functions.
    * gcc/diagnose-gotos.c: Add ACC support for BE.
    * gcc/diagnose-gotos.h: Likewise.
    * gcc/common.opt: Add profiling flags for ACC.
    * gcc/c/c-parser.c: Add parsing routing for ACC.
    * gcc/gimple.c: Add ACC representation.
    * gcc/gimple.h: Likewise.
    * gcc/gimple-pretty-print.c: Likewise.
    * gcc/tree-inline.c: Add dependency checks, loop unfolding.
    * gcc/tree-inline.h: Likewise.
    * gcc/c-family/c-pragma.c: Add ACC pragma's and clauses.
    * gcc/c-family/c-pragma.h: Likewise.
    * gcc/c-family/c.opt: Add flag to enable OpenACC
    * gcc/c-family/c-cppbuiltin.c: Add ACC builtins.
    * gcc/tree.c: Add support of OpenACC.
    * gcc/tree.h: Likewise.
    * gcc/gcc.c: Likewise.
    * gcc/tree-dump.c: Likewise.
    * gcc/omp-low.c: Likewise.
    * README.ACC: Add README for OpenACC.
    * Makefile.in: Integrate with GCC build.
    * Makefile.def: Likewise.
    * ChangeLog.ACC : Add ChangeLog for ACC.
    * configure.ac : Add configure flag for OpenCL.
    * configure: Regenerate.



git-svn-id: https://gcc.gnu.org/svn/gcc/branches/openacc-1_0-branch@202939 138bc75d-0d04-0410-961f-82ee72b054a4

597 files changed, 42491 insertions, 161 deletions

diff --git a/ChangeLog.ACC b/ChangeLog.ACC
new file mode 100644
index 00000000000..6e019c77b8a
--- /dev/null
+++ b/ChangeLog.ACC
@@ -0,0 +1,79 @@
+26-09-2013 Evgeny Gavrin <e.gavrin@samsung.com>
+    Initial source drop for OpenACC implementation
+
+    Dmitry Bocharnikov <dmitry.b@samsung.com>
+    Evgeny Gavrin <e.gavrin@samsung.com>
+    Ilmir Usmanov <i.usmanov@samsung.com>
+
+    * liboacc/*: Add runtime library for OpenACC.
+    * gcc/Makefile.in: Likewise.
+    * gcc/oacc-builtins.def: Add builtins for ACC.
+    * gcc/gimple-opencl.c: Add OpenCL generation.
+    * gcc/gimple-opencl.h: Likewise.
+    * gcc/oacc-low.c: Add OpenACC lowering pass.
+    * gcc/gimple-low.c: Likewise.
+    * gcc/builtin-types.def: Add support of OpenACC.
+    * gcc/gsstruct.def: Likewise.
+    * gcc/tree.def: Likewise.
+    * gcc/treestruct.def: Likewise.
+    * gcc/tree-cfg.c: Likewise.
+    * gcc/tree-core.h: Likewise.
+    * gcc/cp/cp-tree.h: Likewise.
+    * gcc/cp/decl.c: Likewise.
+    * gcc/cp/semantics.c: Likewise.
+    * gcc/cp/parser.c: Likewise.
+    * gcc/cp/parser.h: Likewise.
+    * gcc/cp/name-lookup.c: Likewise.
+    * gcc/cp/name-lookup.h: Likewise.
+    * gcc/tree-pass.h: Likewise.
+    * gcc/gimple.def: Likewise.
+    * gcc/testsuite/gfortran.dg/gacc: Add Fortran tests
+    * gcc/passes.def: Add OpenACC passes.
+    * gcc/tree-pretty-print.c: Add some pp funcs.
+    * gcc/tree-pretty-print.h: Likewise.
+    * gcc/builtins.def: Add builtins for OpenACC.
+    * gcc/fortran/*: Add ACC support for Fortran.
+    * gcc/fortran/gfortran.h: Likewise.
+    * gcc/fortran/lang.opt: Likewise..
+    * gcc/fortran/trans-stmt.h: Likewise.
+    * gcc/fortran/scanner.c: Likewise.
+    * gcc/fortran/trans-openacc.c: Likewise.
+    * gcc/fortran/resolve.c: Likewise.
+    * gcc/fortran/f95-lang.c: Likewise.
+    * gcc/fortran/match.c: Likewise.
+    * gcc/fortran/match.h: Likewise.
+    * gcc/fortran/types.def: Likewise.
+    * gcc/fortran/decl.c: Likewise.
+    * gcc/fortran/openacc.c: Likewise.
+    * gcc/fortran/dump-parse-tree.c: Likewise.
+    * gcc/fortran/Make-lang.in: Likewise.
+    * gcc/fortran/trans.c: Likewise.
+    * gcc/fortran/st.c: Likewise.
+    * gcc/fortran/parse.c: Likewise.
+    * gcc/fortran/parse.h: Likewise.
+    * gcc/fortran/options.c: Likewise.
+    * gcc/gimplify.c: Add gimplification functions.
+    * gcc/diagnose-gotos.c: Add ACC support for BE.
+    * gcc/diagnose-gotos.h: Likewise.
+    * gcc/common.opt: Add profiling flags for ACC.
+    * gcc/c/c-parser.c: Add parsing routing for ACC.
+    * gcc/gimple.c: Add ACC representation.
+    * gcc/gimple.h: Likewise.
+    * gcc/gimple-pretty-print.c: Likewise.
+    * gcc/tree-inline.c: Add dependency checks, loop unfolding.
+    * gcc/tree-inline.h: Likewise.
+    * gcc/c-family/c-pragma.c: Add ACC pragma's and clauses.
+    * gcc/c-family/c-pragma.h: Likewise.
+    * gcc/c-family/c.opt: Add flag to enable OpenACC
+    * gcc/c-family/c-cppbuiltin.c: Add ACC builtins.
+    * gcc/tree.c: Add support of OpenACC.
+    * gcc/tree.h: Likewise.
+    * gcc/gcc.c: Likewise.
+    * gcc/tree-dump.c: Likewise.
+    * gcc/omp-low.c: Likewise.
+    * README.ACC: Add README for OpenACC.
+    * Makefile.in: Integrate with GCC build.
+    * Makefile.def: Likewise.
+    * ChangeLog.ACC : Add ChangeLog for ACC.
+    * configure.ac : Add configure flag for OpenCL.
+    * configure: Regenerate.
diff --git a/Makefile.def b/Makefile.def
index 3ba1a5b9a3a..41f0ea4231b 100644
--- a/Makefile.def
+++ b/Makefile.def
@@ -151,6 +151,7 @@ target_modules = { module= libada; };
 target_modules = { module= libgomp; bootstrap= true; lib_path=.libs; };
 target_modules = { module= libitm; lib_path=.libs; };
 target_modules = { module= libatomic; lib_path=.libs; };
+target_modules = { module= liboacc; lib_path=.libs; };
 
 // These are (some of) the make targets to be done in each subdirectory.
 // Not all; these are the ones which don't have special options.
diff --git a/Makefile.in b/Makefile.in
index a13771d40eb..3bf5f4c30d4 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -575,7 +575,7 @@ all:
 
 # This is the list of directories that may be needed in RPATH_ENVVAR
 # so that programs built for the target machine work.
-TARGET_LIB_PATH = $(TARGET_LIB_PATH_libstdc++-v3)$(TARGET_LIB_PATH_libmudflap)$(TARGET_LIB_PATH_libsanitizer)$(TARGET_LIB_PATH_libvtv)$(TARGET_LIB_PATH_libssp)$(TARGET_LIB_PATH_libgomp)$(TARGET_LIB_PATH_libitm)$(TARGET_LIB_PATH_libatomic)$(HOST_LIB_PATH_gcc)
+TARGET_LIB_PATH = $(TARGET_LIB_PATH_libstdc++-v3)$(TARGET_LIB_PATH_libmudflap)$(TARGET_LIB_PATH_libsanitizer)$(TARGET_LIB_PATH_libvtv)$(TARGET_LIB_PATH_libssp)$(TARGET_LIB_PATH_libgomp)$(TARGET_LIB_PATH_libitm)$(TARGET_LIB_PATH_libatomic)$(TARGET_LIB_PATH_liboacc)$(HOST_LIB_PATH_gcc)
 
 @if target-libstdc++-v3
 TARGET_LIB_PATH_libstdc++-v3 = $$r/$(TARGET_SUBDIR)/libstdc++-v3/src/.libs:
@@ -609,6 +609,10 @@ TARGET_LIB_PATH_libitm = $$r/$(TARGET_SUBDIR)/libitm/.libs:
 TARGET_LIB_PATH_libatomic = $$r/$(TARGET_SUBDIR)/libatomic/.libs:
 @endif target-libatomic
 
+@if target-liboacc
+TARGET_LIB_PATH_liboacc = $$r/$(TARGET_SUBDIR)/liboacc/.libs:
+@endif target-liboacc
+
 
 
 # This is the list of directories that may be needed in RPATH_ENVVAR
@@ -949,7 +953,8 @@ configure-target:  \
     maybe-configure-target-libada \
     maybe-configure-target-libgomp \
     maybe-configure-target-libitm \
-    maybe-configure-target-libatomic
+    maybe-configure-target-libatomic \
+    maybe-configure-target-liboacc
 
 # The target built for a native non-bootstrap build.
 .PHONY: all
@@ -1108,6 +1113,7 @@ all-target: maybe-all-target-libgomp
 @endif target-libgomp-no-bootstrap
 all-target: maybe-all-target-libitm
 all-target: maybe-all-target-libatomic
+all-target: maybe-all-target-liboacc
 
 # Do a target for all the subdirectories.  A ``make do-X'' will do a
 # ``make X'' in all subdirectories (because, in general, there is a
@@ -1196,6 +1202,7 @@ info-target: maybe-info-target-libada
 info-target: maybe-info-target-libgomp
 info-target: maybe-info-target-libitm
 info-target: maybe-info-target-libatomic
+info-target: maybe-info-target-liboacc
 
 .PHONY: do-dvi
 do-dvi:
@@ -1279,6 +1286,7 @@ dvi-target: maybe-dvi-target-libada
 dvi-target: maybe-dvi-target-libgomp
 dvi-target: maybe-dvi-target-libitm
 dvi-target: maybe-dvi-target-libatomic
+dvi-target: maybe-dvi-target-liboacc
 
 .PHONY: do-pdf
 do-pdf:
@@ -1362,6 +1370,7 @@ pdf-target: maybe-pdf-target-libada
 pdf-target: maybe-pdf-target-libgomp
 pdf-target: maybe-pdf-target-libitm
 pdf-target: maybe-pdf-target-libatomic
+pdf-target: maybe-pdf-target-liboacc
 
 .PHONY: do-html
 do-html:
@@ -1445,6 +1454,7 @@ html-target: maybe-html-target-libada
 html-target: maybe-html-target-libgomp
 html-target: maybe-html-target-libitm
 html-target: maybe-html-target-libatomic
+html-target: maybe-html-target-liboacc
 
 .PHONY: do-TAGS
 do-TAGS:
@@ -1528,6 +1538,7 @@ TAGS-target: maybe-TAGS-target-libada
 TAGS-target: maybe-TAGS-target-libgomp
 TAGS-target: maybe-TAGS-target-libitm
 TAGS-target: maybe-TAGS-target-libatomic
+TAGS-target: maybe-TAGS-target-liboacc
 
 .PHONY: do-install-info
 do-install-info:
@@ -1611,6 +1622,7 @@ install-info-target: maybe-install-info-target-libada
 install-info-target: maybe-install-info-target-libgomp
 install-info-target: maybe-install-info-target-libitm
 install-info-target: maybe-install-info-target-libatomic
+install-info-target: maybe-install-info-target-liboacc
 
 .PHONY: do-install-pdf
 do-install-pdf:
@@ -1694,6 +1706,7 @@ install-pdf-target: maybe-install-pdf-target-libada
 install-pdf-target: maybe-install-pdf-target-libgomp
 install-pdf-target: maybe-install-pdf-target-libitm
 install-pdf-target: maybe-install-pdf-target-libatomic
+install-pdf-target: maybe-install-pdf-target-liboacc
 
 .PHONY: do-install-html
 do-install-html:
@@ -1777,6 +1790,7 @@ install-html-target: maybe-install-html-target-libada
 install-html-target: maybe-install-html-target-libgomp
 install-html-target: maybe-install-html-target-libitm
 install-html-target: maybe-install-html-target-libatomic
+install-html-target: maybe-install-html-target-liboacc
 
 .PHONY: do-installcheck
 do-installcheck:
@@ -1860,6 +1874,7 @@ installcheck-target: maybe-installcheck-target-libada
 installcheck-target: maybe-installcheck-target-libgomp
 installcheck-target: maybe-installcheck-target-libitm
 installcheck-target: maybe-installcheck-target-libatomic
+installcheck-target: maybe-installcheck-target-liboacc
 
 .PHONY: do-mostlyclean
 do-mostlyclean:
@@ -1943,6 +1958,7 @@ mostlyclean-target: maybe-mostlyclean-target-libada
 mostlyclean-target: maybe-mostlyclean-target-libgomp
 mostlyclean-target: maybe-mostlyclean-target-libitm
 mostlyclean-target: maybe-mostlyclean-target-libatomic
+mostlyclean-target: maybe-mostlyclean-target-liboacc
 
 .PHONY: do-clean
 do-clean:
@@ -2026,6 +2042,7 @@ clean-target: maybe-clean-target-libada
 clean-target: maybe-clean-target-libgomp
 clean-target: maybe-clean-target-libitm
 clean-target: maybe-clean-target-libatomic
+clean-target: maybe-clean-target-liboacc
 
 .PHONY: do-distclean
 do-distclean:
@@ -2109,6 +2126,7 @@ distclean-target: maybe-distclean-target-libada
 distclean-target: maybe-distclean-target-libgomp
 distclean-target: maybe-distclean-target-libitm
 distclean-target: maybe-distclean-target-libatomic
+distclean-target: maybe-distclean-target-liboacc
 
 .PHONY: do-maintainer-clean
 do-maintainer-clean:
@@ -2192,6 +2210,7 @@ maintainer-clean-target: maybe-maintainer-clean-target-libada
 maintainer-clean-target: maybe-maintainer-clean-target-libgomp
 maintainer-clean-target: maybe-maintainer-clean-target-libitm
 maintainer-clean-target: maybe-maintainer-clean-target-libatomic
+maintainer-clean-target: maybe-maintainer-clean-target-liboacc
 
 
 # Here are the targets which correspond to the do-X targets.
@@ -2329,7 +2348,8 @@ check-target:  \
     maybe-check-target-libada \
     maybe-check-target-libgomp \
     maybe-check-target-libitm \
-    maybe-check-target-libatomic
+    maybe-check-target-libatomic \
+    maybe-check-target-liboacc
 
 do-check:
 	@: $(MAKE); $(unstage)
@@ -2485,7 +2505,8 @@ install-target:  \
     maybe-install-target-libada \
     maybe-install-target-libgomp \
     maybe-install-target-libitm \
-    maybe-install-target-libatomic
+    maybe-install-target-libatomic \
+    maybe-install-target-liboacc
 
 uninstall:
 	@echo "the uninstall target is not supported in this tree"
@@ -2588,7 +2609,8 @@ install-strip-target:  \
     maybe-install-strip-target-libada \
     maybe-install-strip-target-libgomp \
     maybe-install-strip-target-libitm \
-    maybe-install-strip-target-libatomic
+    maybe-install-strip-target-libatomic \
+    maybe-install-strip-target-liboacc
 
 
 ### other supporting targets
@@ -44237,6 +44259,463 @@ maintainer-clean-target-libatomic:
 
 
 
+
+
+.PHONY: configure-target-liboacc maybe-configure-target-liboacc
+maybe-configure-target-liboacc:
+@if gcc-bootstrap
+configure-target-liboacc: stage_current
+@endif gcc-bootstrap
+@if target-liboacc
+maybe-configure-target-liboacc: configure-target-liboacc
+configure-target-liboacc: 
+	@: $(MAKE); $(unstage)
+	@r=`${PWD_COMMAND}`; export r; \
+	s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+	echo "Checking multilib configuration for liboacc..."; \
+	$(SHELL) $(srcdir)/mkinstalldirs $(TARGET_SUBDIR)/liboacc ; \
+	$(CC_FOR_TARGET) --print-multi-lib > $(TARGET_SUBDIR)/liboacc/multilib.tmp 2> /dev/null ; \
+	if test -r $(TARGET_SUBDIR)/liboacc/multilib.out; then \
+	  if cmp -s $(TARGET_SUBDIR)/liboacc/multilib.tmp $(TARGET_SUBDIR)/liboacc/multilib.out; then \
+	    rm -f $(TARGET_SUBDIR)/liboacc/multilib.tmp; \
+	  else \
+	    rm -f $(TARGET_SUBDIR)/liboacc/Makefile; \
+	    mv $(TARGET_SUBDIR)/liboacc/multilib.tmp $(TARGET_SUBDIR)/liboacc/multilib.out; \
+	  fi; \
+	else \
+	  mv $(TARGET_SUBDIR)/liboacc/multilib.tmp $(TARGET_SUBDIR)/liboacc/multilib.out; \
+	fi; \
+	test ! -f $(TARGET_SUBDIR)/liboacc/Makefile || exit 0; \
+	$(SHELL) $(srcdir)/mkinstalldirs $(TARGET_SUBDIR)/liboacc ; \
+	$(NORMAL_TARGET_EXPORTS)  \
+	echo Configuring in $(TARGET_SUBDIR)/liboacc; \
+	cd "$(TARGET_SUBDIR)/liboacc" || exit 1; \
+	case $(srcdir) in \
+	  /* | [A-Za-z]:[\\/]*) topdir=$(srcdir) ;; \
+	  *) topdir=`echo $(TARGET_SUBDIR)/liboacc/ | \
+		sed -e 's,\./,,g' -e 's,[^/]*/,../,g' `$(srcdir) ;; \
+	esac; \
+	srcdiroption="--srcdir=$${topdir}/liboacc"; \
+	libsrcdir="$$s/liboacc"; \
+	rm -f no-such-file || : ; \
+	CONFIG_SITE=no-such-file $(SHELL) $${libsrcdir}/configure \
+	  $(TARGET_CONFIGARGS) --build=${build_alias} --host=${target_alias} \
+	  --target=${target_alias} $${srcdiroption}  \
+	  || exit 1
+@endif target-liboacc
+
+
+
+
+
+.PHONY: all-target-liboacc maybe-all-target-liboacc
+maybe-all-target-liboacc:
+@if gcc-bootstrap
+all-target-liboacc: stage_current
+@endif gcc-bootstrap
+@if target-liboacc
+TARGET-target-liboacc=all
+maybe-all-target-liboacc: all-target-liboacc
+all-target-liboacc: configure-target-liboacc
+	@: $(MAKE); $(unstage)
+	@r=`${PWD_COMMAND}`; export r; \
+	s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+	$(NORMAL_TARGET_EXPORTS)  \
+	(cd $(TARGET_SUBDIR)/liboacc && \
+	  $(MAKE) $(BASE_FLAGS_TO_PASS) $(EXTRA_TARGET_FLAGS)   \
+		$(TARGET-target-liboacc))
+@endif target-liboacc
+
+
+
+
+
+.PHONY: check-target-liboacc maybe-check-target-liboacc
+maybe-check-target-liboacc:
+@if target-liboacc
+maybe-check-target-liboacc: check-target-liboacc
+
+check-target-liboacc:
+	@: $(MAKE); $(unstage)
+	@r=`${PWD_COMMAND}`; export r; \
+	s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+	$(NORMAL_TARGET_EXPORTS) \
+	(cd $(TARGET_SUBDIR)/liboacc && \
+	  $(MAKE) $(TARGET_FLAGS_TO_PASS)   check)
+
+@endif target-liboacc
+
+.PHONY: install-target-liboacc maybe-install-target-liboacc
+maybe-install-target-liboacc:
+@if target-liboacc
+maybe-install-target-liboacc: install-target-liboacc
+
+install-target-liboacc: installdirs
+	@: $(MAKE); $(unstage)
+	@r=`${PWD_COMMAND}`; export r; \
+	s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+	$(NORMAL_TARGET_EXPORTS) \
+	(cd $(TARGET_SUBDIR)/liboacc && \
+	  $(MAKE) $(TARGET_FLAGS_TO_PASS)  install)
+
+@endif target-liboacc
+
+.PHONY: install-strip-target-liboacc maybe-install-strip-target-liboacc
+maybe-install-strip-target-liboacc:
+@if target-liboacc
+maybe-install-strip-target-liboacc: install-strip-target-liboacc
+
+install-strip-target-liboacc: installdirs
+	@: $(MAKE); $(unstage)
+	@r=`${PWD_COMMAND}`; export r; \
+	s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+	$(NORMAL_TARGET_EXPORTS) \
+	(cd $(TARGET_SUBDIR)/liboacc && \
+	  $(MAKE) $(TARGET_FLAGS_TO_PASS)  install-strip)
+
+@endif target-liboacc
+
+# Other targets (info, dvi, pdf, etc.)
+
+.PHONY: maybe-info-target-liboacc info-target-liboacc
+maybe-info-target-liboacc:
+@if target-liboacc
+maybe-info-target-liboacc: info-target-liboacc
+
+info-target-liboacc: \
+    configure-target-liboacc 
+	@: $(MAKE); $(unstage)
+	@[ -f $(TARGET_SUBDIR)/liboacc/Makefile ] || exit 0 ; \
+	r=`${PWD_COMMAND}`; export r; \
+	s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+	$(NORMAL_TARGET_EXPORTS) \
+	echo "Doing info in $(TARGET_SUBDIR)/liboacc" ; \
+	for flag in $(EXTRA_TARGET_FLAGS); do \
+	  eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
+	done; \
+	(cd $(TARGET_SUBDIR)/liboacc && \
+	  $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
+	          "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
+	          "RANLIB=$${RANLIB}" \
+	          "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
+	           info) \
+	  || exit 1
+
+@endif target-liboacc
+
+.PHONY: maybe-dvi-target-liboacc dvi-target-liboacc
+maybe-dvi-target-liboacc:
+@if target-liboacc
+maybe-dvi-target-liboacc: dvi-target-liboacc
+
+dvi-target-liboacc: \
+    configure-target-liboacc 
+	@: $(MAKE); $(unstage)
+	@[ -f $(TARGET_SUBDIR)/liboacc/Makefile ] || exit 0 ; \
+	r=`${PWD_COMMAND}`; export r; \
+	s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+	$(NORMAL_TARGET_EXPORTS) \
+	echo "Doing dvi in $(TARGET_SUBDIR)/liboacc" ; \
+	for flag in $(EXTRA_TARGET_FLAGS); do \
+	  eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
+	done; \
+	(cd $(TARGET_SUBDIR)/liboacc && \
+	  $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
+	          "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
+	          "RANLIB=$${RANLIB}" \
+	          "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
+	           dvi) \
+	  || exit 1
+
+@endif target-liboacc
+
+.PHONY: maybe-pdf-target-liboacc pdf-target-liboacc
+maybe-pdf-target-liboacc:
+@if target-liboacc
+maybe-pdf-target-liboacc: pdf-target-liboacc
+
+pdf-target-liboacc: \
+    configure-target-liboacc 
+	@: $(MAKE); $(unstage)
+	@[ -f $(TARGET_SUBDIR)/liboacc/Makefile ] || exit 0 ; \
+	r=`${PWD_COMMAND}`; export r; \
+	s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+	$(NORMAL_TARGET_EXPORTS) \
+	echo "Doing pdf in $(TARGET_SUBDIR)/liboacc" ; \
+	for flag in $(EXTRA_TARGET_FLAGS); do \
+	  eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
+	done; \
+	(cd $(TARGET_SUBDIR)/liboacc && \
+	  $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
+	          "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
+	          "RANLIB=$${RANLIB}" \
+	          "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
+	           pdf) \
+	  || exit 1
+
+@endif target-liboacc
+
+.PHONY: maybe-html-target-liboacc html-target-liboacc
+maybe-html-target-liboacc:
+@if target-liboacc
+maybe-html-target-liboacc: html-target-liboacc
+
+html-target-liboacc: \
+    configure-target-liboacc 
+	@: $(MAKE); $(unstage)
+	@[ -f $(TARGET_SUBDIR)/liboacc/Makefile ] || exit 0 ; \
+	r=`${PWD_COMMAND}`; export r; \
+	s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+	$(NORMAL_TARGET_EXPORTS) \
+	echo "Doing html in $(TARGET_SUBDIR)/liboacc" ; \
+	for flag in $(EXTRA_TARGET_FLAGS); do \
+	  eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
+	done; \
+	(cd $(TARGET_SUBDIR)/liboacc && \
+	  $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
+	          "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
+	          "RANLIB=$${RANLIB}" \
+	          "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
+	           html) \
+	  || exit 1
+
+@endif target-liboacc
+
+.PHONY: maybe-TAGS-target-liboacc TAGS-target-liboacc
+maybe-TAGS-target-liboacc:
+@if target-liboacc
+maybe-TAGS-target-liboacc: TAGS-target-liboacc
+
+TAGS-target-liboacc: \
+    configure-target-liboacc 
+	@: $(MAKE); $(unstage)
+	@[ -f $(TARGET_SUBDIR)/liboacc/Makefile ] || exit 0 ; \
+	r=`${PWD_COMMAND}`; export r; \
+	s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+	$(NORMAL_TARGET_EXPORTS) \
+	echo "Doing TAGS in $(TARGET_SUBDIR)/liboacc" ; \
+	for flag in $(EXTRA_TARGET_FLAGS); do \
+	  eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
+	done; \
+	(cd $(TARGET_SUBDIR)/liboacc && \
+	  $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
+	          "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
+	          "RANLIB=$${RANLIB}" \
+	          "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
+	           TAGS) \
+	  || exit 1
+
+@endif target-liboacc
+
+.PHONY: maybe-install-info-target-liboacc install-info-target-liboacc
+maybe-install-info-target-liboacc:
+@if target-liboacc
+maybe-install-info-target-liboacc: install-info-target-liboacc
+
+install-info-target-liboacc: \
+    configure-target-liboacc \
+    info-target-liboacc 
+	@: $(MAKE); $(unstage)
+	@[ -f $(TARGET_SUBDIR)/liboacc/Makefile ] || exit 0 ; \
+	r=`${PWD_COMMAND}`; export r; \
+	s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+	$(NORMAL_TARGET_EXPORTS) \
+	echo "Doing install-info in $(TARGET_SUBDIR)/liboacc" ; \
+	for flag in $(EXTRA_TARGET_FLAGS); do \
+	  eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
+	done; \
+	(cd $(TARGET_SUBDIR)/liboacc && \
+	  $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
+	          "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
+	          "RANLIB=$${RANLIB}" \
+	          "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
+	           install-info) \
+	  || exit 1
+
+@endif target-liboacc
+
+.PHONY: maybe-install-pdf-target-liboacc install-pdf-target-liboacc
+maybe-install-pdf-target-liboacc:
+@if target-liboacc
+maybe-install-pdf-target-liboacc: install-pdf-target-liboacc
+
+install-pdf-target-liboacc: \
+    configure-target-liboacc \
+    pdf-target-liboacc 
+	@: $(MAKE); $(unstage)
+	@[ -f $(TARGET_SUBDIR)/liboacc/Makefile ] || exit 0 ; \
+	r=`${PWD_COMMAND}`; export r; \
+	s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+	$(NORMAL_TARGET_EXPORTS) \
+	echo "Doing install-pdf in $(TARGET_SUBDIR)/liboacc" ; \
+	for flag in $(EXTRA_TARGET_FLAGS); do \
+	  eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
+	done; \
+	(cd $(TARGET_SUBDIR)/liboacc && \
+	  $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
+	          "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
+	          "RANLIB=$${RANLIB}" \
+	          "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
+	           install-pdf) \
+	  || exit 1
+
+@endif target-liboacc
+
+.PHONY: maybe-install-html-target-liboacc install-html-target-liboacc
+maybe-install-html-target-liboacc:
+@if target-liboacc
+maybe-install-html-target-liboacc: install-html-target-liboacc
+
+install-html-target-liboacc: \
+    configure-target-liboacc \
+    html-target-liboacc 
+	@: $(MAKE); $(unstage)
+	@[ -f $(TARGET_SUBDIR)/liboacc/Makefile ] || exit 0 ; \
+	r=`${PWD_COMMAND}`; export r; \
+	s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+	$(NORMAL_TARGET_EXPORTS) \
+	echo "Doing install-html in $(TARGET_SUBDIR)/liboacc" ; \
+	for flag in $(EXTRA_TARGET_FLAGS); do \
+	  eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
+	done; \
+	(cd $(TARGET_SUBDIR)/liboacc && \
+	  $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
+	          "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
+	          "RANLIB=$${RANLIB}" \
+	          "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
+	           install-html) \
+	  || exit 1
+
+@endif target-liboacc
+
+.PHONY: maybe-installcheck-target-liboacc installcheck-target-liboacc
+maybe-installcheck-target-liboacc:
+@if target-liboacc
+maybe-installcheck-target-liboacc: installcheck-target-liboacc
+
+installcheck-target-liboacc: \
+    configure-target-liboacc 
+	@: $(MAKE); $(unstage)
+	@[ -f $(TARGET_SUBDIR)/liboacc/Makefile ] || exit 0 ; \
+	r=`${PWD_COMMAND}`; export r; \
+	s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+	$(NORMAL_TARGET_EXPORTS) \
+	echo "Doing installcheck in $(TARGET_SUBDIR)/liboacc" ; \
+	for flag in $(EXTRA_TARGET_FLAGS); do \
+	  eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
+	done; \
+	(cd $(TARGET_SUBDIR)/liboacc && \
+	  $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
+	          "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
+	          "RANLIB=$${RANLIB}" \
+	          "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
+	           installcheck) \
+	  || exit 1
+
+@endif target-liboacc
+
+.PHONY: maybe-mostlyclean-target-liboacc mostlyclean-target-liboacc
+maybe-mostlyclean-target-liboacc:
+@if target-liboacc
+maybe-mostlyclean-target-liboacc: mostlyclean-target-liboacc
+
+mostlyclean-target-liboacc: 
+	@: $(MAKE); $(unstage)
+	@[ -f $(TARGET_SUBDIR)/liboacc/Makefile ] || exit 0 ; \
+	r=`${PWD_COMMAND}`; export r; \
+	s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+	$(NORMAL_TARGET_EXPORTS) \
+	echo "Doing mostlyclean in $(TARGET_SUBDIR)/liboacc" ; \
+	for flag in $(EXTRA_TARGET_FLAGS); do \
+	  eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
+	done; \
+	(cd $(TARGET_SUBDIR)/liboacc && \
+	  $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
+	          "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
+	          "RANLIB=$${RANLIB}" \
+	          "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
+	           mostlyclean) \
+	  || exit 1
+
+@endif target-liboacc
+
+.PHONY: maybe-clean-target-liboacc clean-target-liboacc
+maybe-clean-target-liboacc:
+@if target-liboacc
+maybe-clean-target-liboacc: clean-target-liboacc
+
+clean-target-liboacc: 
+	@: $(MAKE); $(unstage)
+	@[ -f $(TARGET_SUBDIR)/liboacc/Makefile ] || exit 0 ; \
+	r=`${PWD_COMMAND}`; export r; \
+	s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+	$(NORMAL_TARGET_EXPORTS) \
+	echo "Doing clean in $(TARGET_SUBDIR)/liboacc" ; \
+	for flag in $(EXTRA_TARGET_FLAGS); do \
+	  eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
+	done; \
+	(cd $(TARGET_SUBDIR)/liboacc && \
+	  $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
+	          "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
+	          "RANLIB=$${RANLIB}" \
+	          "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
+	           clean) \
+	  || exit 1
+
+@endif target-liboacc
+
+.PHONY: maybe-distclean-target-liboacc distclean-target-liboacc
+maybe-distclean-target-liboacc:
+@if target-liboacc
+maybe-distclean-target-liboacc: distclean-target-liboacc
+
+distclean-target-liboacc: 
+	@: $(MAKE); $(unstage)
+	@[ -f $(TARGET_SUBDIR)/liboacc/Makefile ] || exit 0 ; \
+	r=`${PWD_COMMAND}`; export r; \
+	s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+	$(NORMAL_TARGET_EXPORTS) \
+	echo "Doing distclean in $(TARGET_SUBDIR)/liboacc" ; \
+	for flag in $(EXTRA_TARGET_FLAGS); do \
+	  eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
+	done; \
+	(cd $(TARGET_SUBDIR)/liboacc && \
+	  $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
+	          "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
+	          "RANLIB=$${RANLIB}" \
+	          "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
+	           distclean) \
+	  || exit 1
+
+@endif target-liboacc
+
+.PHONY: maybe-maintainer-clean-target-liboacc maintainer-clean-target-liboacc
+maybe-maintainer-clean-target-liboacc:
+@if target-liboacc
+maybe-maintainer-clean-target-liboacc: maintainer-clean-target-liboacc
+
+maintainer-clean-target-liboacc: 
+	@: $(MAKE); $(unstage)
+	@[ -f $(TARGET_SUBDIR)/liboacc/Makefile ] || exit 0 ; \
+	r=`${PWD_COMMAND}`; export r; \
+	s=`cd $(srcdir); ${PWD_COMMAND}`; export s; \
+	$(NORMAL_TARGET_EXPORTS) \
+	echo "Doing maintainer-clean in $(TARGET_SUBDIR)/liboacc" ; \
+	for flag in $(EXTRA_TARGET_FLAGS); do \
+	  eval `echo "$$flag" | sed -e "s|^\([^=]*\)=\(.*\)|\1='\2'; export \1|"`; \
+	done; \
+	(cd $(TARGET_SUBDIR)/liboacc && \
+	  $(MAKE) $(BASE_FLAGS_TO_PASS) "AR=$${AR}" "AS=$${AS}" \
+	          "CC=$${CC}" "CXX=$${CXX}" "LD=$${LD}" "NM=$${NM}" \
+	          "RANLIB=$${RANLIB}" \
+	          "DLLTOOL=$${DLLTOOL}" "WINDRES=$${WINDRES}" "WINDMC=$${WINDMC}" \
+	           maintainer-clean) \
+	  || exit 1
+
+@endif target-liboacc
+
+
+
 @if target-libmudflap
 .PHONY: check-target-libmudflap-c++
 check-target-libmudflap-c++:
@@ -46418,6 +46897,7 @@ configure-stageprofile-target-libgomp: maybe-all-stageprofile-gcc
 configure-stagefeedback-target-libgomp: maybe-all-stagefeedback-gcc
 configure-target-libitm: stage_last
 configure-target-libatomic: stage_last
+configure-target-liboacc: stage_last
 @endif gcc-bootstrap
 
 @if gcc-no-bootstrap
@@ -46445,6 +46925,7 @@ configure-target-libada: maybe-all-gcc
 configure-target-libgomp: maybe-all-gcc
 configure-target-libitm: maybe-all-gcc
 configure-target-libatomic: maybe-all-gcc
+configure-target-liboacc: maybe-all-gcc
 @endif gcc-no-bootstrap
 
 
@@ -47290,6 +47771,7 @@ configure-target-libada: maybe-all-target-libgcc
 configure-target-libgomp: maybe-all-target-libgcc
 configure-target-libitm: maybe-all-target-libgcc
 configure-target-libatomic: maybe-all-target-libgcc
+configure-target-liboacc: maybe-all-target-libgcc
 @endif gcc-no-bootstrap
 
 
@@ -47340,6 +47822,8 @@ configure-target-libitm: maybe-all-target-libstdc++-v3
 
 configure-target-libatomic: maybe-all-target-newlib maybe-all-target-libgloss
 
+configure-target-liboacc: maybe-all-target-newlib maybe-all-target-libgloss
+
 
 CONFIGURE_GDB_TK = @CONFIGURE_GDB_TK@
 GDB_TK = @GDB_TK@
diff --git a/README.ACC b/README.ACC
new file mode 100644
index 00000000000..e69de29bb2d
--- /dev/null
+++ b/README.ACC
diff --git a/configure b/configure
index a91689ff419..c8cf19e7a90 100755
--- a/configure
+++ b/configure
@@ -2782,7 +2782,8 @@ target_libraries="target-libgcc \
 		${libgcj} \
 		target-libobjc \
 		target-libada \
-		target-libgo"
+		target-libgo \
+		target-liboacc"
 
 # these tools are built using the target libraries, and are intended to
 # run only in the target environment
diff --git a/configure.ac b/configure.ac
index d72b40a7af9..846cf24a323 100644
--- a/configure.ac
+++ b/configure.ac
@@ -169,7 +169,8 @@ target_libraries="target-libgcc \
 		${libgcj} \
 		target-libobjc \
 		target-libada \
-		target-libgo"
+		target-libgo \
+		target-liboacc"
 
 # these tools are built using the target libraries, and are intended to
 # run only in the target environment
diff --git a/gcc/Makefile.in b/gcc/Makefile.in
index a2e3f7af2ba..5bc86ae41ed 100644
--- a/gcc/Makefile.in
+++ b/gcc/Makefile.in
@@ -869,7 +869,8 @@ RTL_ERROR_H = rtl-error.h $(RTL_H) $(DIAGNOSTIC_CORE_H)
 READ_MD_H = $(OBSTACK_H) $(HASHTAB_H) read-md.h
 PARAMS_H = params.h params.def
 BUILTINS_DEF = builtins.def sync-builtins.def omp-builtins.def \
-	gtm-builtins.def sanitizer.def cilkplus.def
+	gtm-builtins.def sanitizer.def cilkplus.def oacc-builtins.def
+
 INTERNAL_FN_DEF = internal-fn.def
 INTERNAL_FN_H = internal-fn.h $(INTERNAL_FN_DEF)
 TREE_CORE_H = tree-core.h coretypes.h all-tree.def tree.def \
@@ -1225,6 +1226,7 @@ OBJS = \
 	df-problems.o \
 	df-scan.o \
 	dfp.o \
+	diagnose-gotos.o \
 	dojump.o \
 	dominance.o \
 	domwalk.o \
@@ -1251,6 +1253,7 @@ OBJS = \
 	gimple-iterator.o \
 	gimple-fold.o \
 	gimple-low.o \
+	gimple-opencl.o \
 	gimple-pretty-print.o \
 	gimple-ssa-strength-reduction.o \
 	gimple-streamer-in.o \
@@ -1326,6 +1329,7 @@ OBJS = \
 	mcf.o \
 	mode-switching.o \
 	modulo-sched.o \
+	oacc-low.o \
 	omega.o \
 	omp-low.o \
 	optabs.o \
@@ -2705,6 +2709,15 @@ fold-const.o : fold-const.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \
    $(TREE_H) $(FLAGS_H) $(DIAGNOSTIC_CORE_H) $(HASH_TABLE_H) $(EXPR_H) \
    $(RTL_H) $(GGC_H) $(TM_P_H) langhooks.h $(MD5_H) intl.h $(TARGET_H) \
    $(GIMPLE_H) realmpfr.h $(TREE_SSA_H)
+oacc-low.o : oacc-low.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \
+   $(GIMPLE_H) $(TREE_INLINE_H) $(DIAGNOSTIC_CORE_H) $(TREE_FLOW_H) \
+   $(EXPR_H) $(TREE_PASS_H) $(SPLAY_TREE_H) $(CFGLOOP_H) $(GIMPLE_PRETTY_PRINT_H) \
+   $(TREE_DATA_REF_H) tree-scalar-evolution.h $(SSAEXPAND_H) gt-oacc-low.h
+gimple-opencl.o : gimple-opencl.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
+	$(GIMPLE_PRETTY_PRINT_H) $(DUMPFILE_H) $(TREE_FLOW_H) $(SSAEXPAND_H) \
+	gimple-opencl.h
+diagnose-gotos.o : diagnose-gotos.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
+	$(TM_H) $(GIMPLE_H) tree-iterator.h $(SPLAY_TREE_H) diagnose-gotos.h
 diagnostic.o : diagnostic.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
    version.h $(DEMANGLE_H) $(INPUT_H) intl.h $(BACKTRACE_H) $(DIAGNOSTIC_H) \
    diagnostic.def diagnostic-color.h
@@ -3832,6 +3845,7 @@ GTFILES = $(CPP_ID_DATA_H) $(srcdir)/input.h $(srcdir)/coretypes.h \
   $(srcdir)/tree-profile.c $(srcdir)/tree-nested.c \
   $(srcdir)/tree-parloops.c \
   $(srcdir)/omp-low.c \
+  $(srcdir)/oacc-low.c \
   $(srcdir)/targhooks.c $(out_file) $(srcdir)/passes.c $(srcdir)/cgraphunit.c \
   $(srcdir)/cgraphclones.c \
   $(srcdir)/tree-ssa-propagate.c \
diff --git a/gcc/builtin-types.def b/gcc/builtin-types.def
index 2634eccabab..28cd9d32ff8 100644
--- a/gcc/builtin-types.def
+++ b/gcc/builtin-types.def
@@ -576,3 +576,23 @@ DEF_FUNCTION_TYPE_2 (BT_FN_VOID_VPTR_LDOUBLE, BT_VOID,
 		     BT_VOLATILE_PTR, BT_LONGDOUBLE)
 DEF_FUNCTION_TYPE_2 (BT_FN_VOID_VPTR_SIZE, BT_VOID,
 		     BT_VOLATILE_PTR, BT_SIZE)
+
+DEF_POINTER_TYPE (BT_PTR_VOID, BT_VOID)
+DEF_FUNCTION_TYPE_1 (BT_FN_VOIDPTR_VOID, BT_PTR_VOID, BT_VOID)
+DEF_FUNCTION_TYPE_1 (BT_FN_VOID_VOIDPTR, BT_VOID, BT_PTR_VOID)
+DEF_FUNCTION_TYPE_1	(BT_FN_VOIDPTR_VOIDPTR, BT_PTR_VOID, BT_PTR_VOID)
+DEF_FUNCTION_TYPE_2 (BT_FN_VOIDPTR_CONST_STRING_CONST_STRING, BT_PTR_VOID,
+			BT_CONST_STRING, BT_CONST_STRING)
+DEF_FUNCTION_TYPE_2 (BT_FN_VOID_VOIDPTR_UINT, BT_VOID, BT_PTR_VOID, BT_UINT)
+DEF_FUNCTION_TYPE_2 (BT_FN_VOIDPTR_CONST_STRING_INT, BT_PTR_VOID,
+			BT_CONST_STRING, BT_INT)
+DEF_FUNCTION_TYPE_2	(BT_FN_VOID_INT_VOIDPTR, BT_VOID, BT_INT, BT_PTR_VOID)
+DEF_FUNCTION_TYPE_3 (BT_FN_VOID_VOIDPTR_UINT_VOIDPTR, BT_VOID, BT_PTR_VOID,
+			BT_UINT, BT_PTR_VOID)
+DEF_FUNCTION_TYPE_3 (BT_FN_VOID_VOIDPTR_UINT_INT, BT_VOID, BT_PTR_VOID, BT_UINT, BT_INT)
+DEF_FUNCTION_TYPE_4 (BT_FN_VOID_VOIDPTR_UINT_VOIDPTR_UINT, BT_VOID, BT_PTR_VOID,
+			BT_UINT, BT_PTR_VOID, BT_UINT)
+DEF_FUNCTION_TYPE_5 (BT_FN_VOIDPTR_VOIDPTR_UNIT_INT_VOIDPTR_UINT, BT_PTR_VOID,
+			BT_PTR_VOID, BT_UINT, BT_INT, BT_PTR_VOID, BT_UINT)
+DEF_FUNCTION_TYPE_5 (BT_FN_VOID_VOIDPTR_UNIT_INT_VOIDPTR_UINT, BT_VOID, BT_PTR_VOID,
+			BT_UINT, BT_INT, BT_PTR_VOID, BT_UINT)
diff --git a/gcc/builtins.def b/gcc/builtins.def
index 8ccf3ae3578..5e76d4c3646 100644
--- a/gcc/builtins.def
+++ b/gcc/builtins.def
@@ -147,6 +147,13 @@ along with GCC; see the file COPYING3.  If not see
                false, true, true, ATTRS, false, \
 	       (flag_openmp || flag_tree_parallelize_loops))
 
+/* Builtin used by the implementation of OpenACC.  None of these are
+   actually implemented in the compiler; they're all in lib???.  */
+#undef DEF_OACC_BUILTIN
+#define DEF_OACC_BUILTIN(ENUM, NAME, TYPE, ATTRS) \
+  DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE,    \
+               false, true, true, ATTRS, false, flag_openacc)
+
 /* Builtin used by the implementation of GNU TM.  These
    functions are mapped to the actual implementation of the STM library. */
 #undef DEF_TM_BUILTIN
@@ -846,6 +853,9 @@ DEF_GCC_BUILTIN (BUILT_IN_LINE, "LINE", BT_FN_INT, ATTR_NOTHROW_LEAF_LIST)
 /* OpenMP builtins.  */
 #include "omp-builtins.def"
 
+/* OpenACC builtins.  */
+#include "oacc-builtins.def"
+
 /* GTM builtins. */
 #include "gtm-builtins.def"
 
diff --git a/gcc/c-family/c-cppbuiltin.c b/gcc/c-family/c-cppbuiltin.c
index 94078c00460..4751347b703 100644
--- a/gcc/c-family/c-cppbuiltin.c
+++ b/gcc/c-family/c-cppbuiltin.c
@@ -898,6 +898,9 @@ c_cpp_builtins (cpp_reader *pfile)
   if (flag_openmp)
     cpp_define (pfile, "_OPENMP=201107");
 
+  if (flag_openacc)
+    cpp_define (pfile, "_OPENACC=201111");
+
   if (int128_integer_type_node != NULL_TREE)
     builtin_define_type_sizeof ("__SIZEOF_INT128__",
 			        int128_integer_type_node);
diff --git a/gcc/c-family/c-pragma.c b/gcc/c-family/c-pragma.c
index 309859fc8ec..23f2873ad8a 100644
--- a/gcc/c-family/c-pragma.c
+++ b/gcc/c-family/c-pragma.c
@@ -1182,18 +1182,40 @@ static const struct omp_pragma_def omp_pragmas[] = {
   { "threadprivate", PRAGMA_OMP_THREADPRIVATE }
 };
 
+struct acc_pragma_def { const char *name; unsigned int id; };
+static const struct acc_pragma_def acc_pragmas[] = {
+  { "parallel", PRAGMA_ACC_PARALLEL },
+  { "kernels", PRAGMA_ACC_KERNELS },
+  { "data", PRAGMA_ACC_DATA },
+  { "host_data", PRAGMA_ACC_HOST_DATA },
+  { "cache", PRAGMA_ACC_CACHE },
+  { "wait", PRAGMA_ACC_WAIT },
+  { "update", PRAGMA_ACC_UPDATE },
+  { "loop", PRAGMA_ACC_LOOP },
+  { "declare", PRAGMA_ACC_DECLARE }
+};
+
 void
 c_pp_lookup_pragma (unsigned int id, const char **space, const char **name)
 {
   const int n_omp_pragmas = sizeof (omp_pragmas) / sizeof (*omp_pragmas);
+  const int n_acc_pragmas = sizeof (acc_pragmas) / sizeof (*acc_pragmas);
   int i;
 
   for (i = 0; i < n_omp_pragmas; ++i)
     if (omp_pragmas[i].id == id)
       {
-	*space = "omp";
-	*name = omp_pragmas[i].name;
-	return;
+		*space = "omp";
+		*name = omp_pragmas[i].name;
+		return;
+      }
+
+  for (i = 0; i < n_acc_pragmas; ++i)
+    if (acc_pragmas[i].id == id)
+      {
+		*space = "acc";
+		*name = acc_pragmas[i].name;
+		return;
       }
 
   if (id >= PRAGMA_FIRST_EXTERNAL
@@ -1345,10 +1367,20 @@ init_pragma (void)
       int i;
 
       for (i = 0; i < n_omp_pragmas; ++i)
-	cpp_register_deferred_pragma (parse_in, "omp", omp_pragmas[i].name,
+        cpp_register_deferred_pragma (parse_in, "omp", omp_pragmas[i].name,
 				      omp_pragmas[i].id, true, true);
     }
 
+  if (flag_openacc)
+    {
+      const int n_acc_pragmas = sizeof (acc_pragmas) / sizeof (*acc_pragmas);
+      int i;
+
+      for (i = 0; i < n_acc_pragmas; ++i)
+    	  cpp_register_deferred_pragma (parse_in, "acc", acc_pragmas[i].name,
+				      acc_pragmas[i].id, true, true);
+    }
+
   if (!flag_preprocess_only)
     cpp_register_deferred_pragma (parse_in, "GCC", "pch_preprocess",
 				  PRAGMA_GCC_PCH_PREPROCESS, false, false);
@@ -1384,4 +1416,109 @@ init_pragma (void)
   invoke_plugin_callbacks (PLUGIN_PRAGMAS, NULL);
 }
 
+
+pragma_acc_clause
+pragma_acc_clause_get_name(const char* p, pragma_acc_clause result)
+{
+  switch (p[0]) {
+  case 'a':
+    if (!strcmp("async", p))
+      result = PRAGMA_ACC_CLAUSE_ASYNC;
+
+    break;
+  case 'c':
+    if (!strcmp("collapse", p))
+      result = PRAGMA_ACC_CLAUSE_COLLAPSE;
+    else if (!strcmp("create", p))
+      result = PRAGMA_ACC_CLAUSE_CREATE;
+    else if (!strcmp("copy", p))
+      result = PRAGMA_ACC_CLAUSE_COPY;
+    else if (!strcmp("copyin", p))
+      result = PRAGMA_ACC_CLAUSE_COPYIN;
+    else if (!strcmp("copyout", p))
+      result = PRAGMA_ACC_CLAUSE_COPYOUT;
+
+    break;
+  case 'd':
+    if (!strcmp("device", p))
+      result = PRAGMA_ACC_CLAUSE_DEVICE;
+    else if (!strcmp("deviceptr", p))
+      result = PRAGMA_ACC_CLAUSE_DEVICEPTR;
+    else if (!strcmp("device_resident", p))
+      result = PRAGMA_ACC_CLAUSE_DEVICE_RESIDENT;
+
+    break;
+  case 'f':
+    if (!strcmp("firstprivate", p))
+      result = PRAGMA_ACC_CLAUSE_FIRSTPRIVATE;
+
+    break;
+  case 'g':
+    if (!strcmp("gang", p))
+      result = PRAGMA_ACC_CLAUSE_GANG;
+
+    break;
+  case 'h':
+    if (!strcmp("host", p))
+      result = PRAGMA_ACC_CLAUSE_HOST;
+
+    break;
+  case 's':
+    if (!strcmp("seq", p))
+      result = PRAGMA_ACC_CLAUSE_SEQ;
+
+    break;
+  case 'i':
+    if (!strcmp("independent", p))
+      result = PRAGMA_ACC_CLAUSE_INDEPENDENT;
+
+    break;
+  case 'n':
+    if (!strcmp("num_gangs", p))
+      result = PRAGMA_ACC_CLAUSE_NUM_GANGS;
+    else if (!strcmp("num_workers", p))
+      result = PRAGMA_ACC_CLAUSE_NUM_WORKERS;
+
+    break;
+  case 'p':
+    if (!strcmp("private", p))
+      result = PRAGMA_ACC_CLAUSE_PRIVATE;
+    else if (!strcmp("present", p))
+      result = PRAGMA_ACC_CLAUSE_PRESENT;
+    else if (!strcmp("present_or_copy", p))
+      result = PRAGMA_ACC_CLAUSE_PRESENT_OR_COPY;
+    else if (!strcmp("present_or_copyin", p))
+      result = PRAGMA_ACC_CLAUSE_PRESENT_OR_COPYIN;
+    else if (!strcmp("present_or_copyout", p))
+      result = PRAGMA_ACC_CLAUSE_PRESENT_OR_COPYOUT;
+    else if (!strcmp("present_or_create", p))
+      result = PRAGMA_ACC_CLAUSE_PRESENT_OR_CREATE;
+
+    break;
+  case 'r':
+   if (!strcmp("reduction", p))
+     result = PRAGMA_ACC_CLAUSE_REDUCTION;
+
+   break;
+  case 'v':
+    if (!strcmp("vector", p))
+      result = PRAGMA_ACC_CLAUSE_VECTOR;
+    else if (!strcmp("vector_length", p))
+      result = PRAGMA_ACC_CLAUSE_VECTOR_LENGTH;
+
+    break;
+  case 'u':
+    if (!strcmp("use_device", p))
+      result = PRAGMA_ACC_CLAUSE_USE_DEVICE;
+
+    break;
+  case 'w':
+    if (!strcmp("worker", p))
+      result = PRAGMA_ACC_CLAUSE_WORKER;
+
+    break;
+  }
+  return result;
+}
+
 #include "gt-c-family-c-pragma.h"
diff --git a/gcc/c-family/c-pragma.h b/gcc/c-family/c-pragma.h
index 41215db00a0..12db6febcee 100644
--- a/gcc/c-family/c-pragma.h
+++ b/gcc/c-family/c-pragma.h
@@ -45,6 +45,18 @@ typedef enum pragma_kind {
   PRAGMA_OMP_TASKYIELD,
   PRAGMA_OMP_THREADPRIVATE,
 
+  PRAGMA_ACC_PARALLEL,
+  PRAGMA_ACC_PARALLEL_LOOP,
+  PRAGMA_ACC_KERNELS,
+  PRAGMA_ACC_KERNELS_LOOP,
+  PRAGMA_ACC_DATA,
+  PRAGMA_ACC_CACHE,
+  PRAGMA_ACC_WAIT,
+  PRAGMA_ACC_HOST_DATA,
+  PRAGMA_ACC_LOOP,
+  PRAGMA_ACC_DECLARE,
+  PRAGMA_ACC_UPDATE,
+
   PRAGMA_GCC_PCH_PREPROCESS,
 
   PRAGMA_FIRST_EXTERNAL
@@ -75,6 +87,147 @@ typedef enum pragma_omp_clause {
   PRAGMA_OMP_CLAUSE_MERGEABLE
 } pragma_omp_clause;
 
+
+/* All clauses defined by OpenACC 1.0.
+   Used internally by both C and C++ parsers.  */
+typedef enum pragma_acc_clause {
+  PRAGMA_ACC_CLAUSE_NONE = 0,
+
+  PRAGMA_ACC_CLAUSE_IF,
+  PRAGMA_ACC_CLAUSE_ASYNC,
+  PRAGMA_ACC_CLAUSE_COLLAPSE,
+  PRAGMA_ACC_CLAUSE_SEQ,
+  PRAGMA_ACC_CLAUSE_INDEPENDENT,
+  PRAGMA_ACC_CLAUSE_GANG,
+  PRAGMA_ACC_CLAUSE_WORKER,
+  PRAGMA_ACC_CLAUSE_VECTOR,
+  PRAGMA_ACC_CLAUSE_NUM_GANGS,
+  PRAGMA_ACC_CLAUSE_NUM_WORKERS,
+  PRAGMA_ACC_CLAUSE_VECTOR_LENGTH,
+  PRAGMA_ACC_CLAUSE_REDUCTION,
+  PRAGMA_ACC_CLAUSE_COPY,
+  PRAGMA_ACC_CLAUSE_COPYIN,
+  PRAGMA_ACC_CLAUSE_COPYOUT,
+  PRAGMA_ACC_CLAUSE_CREATE,
+  PRAGMA_ACC_CLAUSE_PRESENT,
+  PRAGMA_ACC_CLAUSE_PRESENT_OR_COPY,
+  PRAGMA_ACC_CLAUSE_PRESENT_OR_COPYIN,
+  PRAGMA_ACC_CLAUSE_PRESENT_OR_COPYOUT,
+  PRAGMA_ACC_CLAUSE_PRESENT_OR_CREATE,
+  PRAGMA_ACC_CLAUSE_HOST,
+  PRAGMA_ACC_CLAUSE_DEVICE,
+  PRAGMA_ACC_CLAUSE_DEVICEPTR,
+  PRAGMA_ACC_CLAUSE_DEVICE_RESIDENT,
+  PRAGMA_ACC_CLAUSE_USE_DEVICE,
+  PRAGMA_ACC_CLAUSE_PRIVATE,
+  PRAGMA_ACC_CLAUSE_FIRSTPRIVATE
+} pragma_acc_clause;
+
+/* OpenACC 1.0:
+ * Mask for parallel clauses
+*/
+#define ACC_PARALLEL_CLAUSE_MASK \
+		( (1u << PRAGMA_ACC_CLAUSE_IF)\
+		| (1u << PRAGMA_ACC_CLAUSE_ASYNC)\
+		| (1u << PRAGMA_ACC_CLAUSE_NUM_GANGS)\
+		| (1u << PRAGMA_ACC_CLAUSE_NUM_WORKERS)\
+		| (1u << PRAGMA_ACC_CLAUSE_VECTOR_LENGTH)\
+		| (1u << PRAGMA_ACC_CLAUSE_REDUCTION)\
+		| (1u << PRAGMA_ACC_CLAUSE_COPY)\
+		| (1u << PRAGMA_ACC_CLAUSE_COPYIN)\
+		| (1u << PRAGMA_ACC_CLAUSE_COPYOUT)\
+		| (1u << PRAGMA_ACC_CLAUSE_CREATE)\
+		| (1u << PRAGMA_ACC_CLAUSE_PRESENT)\
+		| (1u << PRAGMA_ACC_CLAUSE_PRESENT_OR_COPY)\
+		| (1u << PRAGMA_ACC_CLAUSE_PRESENT_OR_COPYIN)\
+		| (1u << PRAGMA_ACC_CLAUSE_PRESENT_OR_COPYOUT)\
+		| (1u << PRAGMA_ACC_CLAUSE_PRESENT_OR_CREATE)\
+		| (1u << PRAGMA_ACC_CLAUSE_DEVICEPTR)\
+		| (1u << PRAGMA_ACC_CLAUSE_PRIVATE)\
+		| (1u << PRAGMA_ACC_CLAUSE_FIRSTPRIVATE))
+
+/* OpenACC 1.0:
+ * Mask for kernels clauses
+*/
+#define ACC_KERNELS_CLAUSE_MASK \
+		( (1u << PRAGMA_ACC_CLAUSE_IF)\
+		| (1u << PRAGMA_ACC_CLAUSE_ASYNC)\
+		| (1u << PRAGMA_ACC_CLAUSE_COPY)\
+		| (1u << PRAGMA_ACC_CLAUSE_COPYIN)\
+		| (1u << PRAGMA_ACC_CLAUSE_COPYOUT)\
+		| (1u << PRAGMA_ACC_CLAUSE_CREATE)\
+		| (1u << PRAGMA_ACC_CLAUSE_PRESENT)\
+		| (1u << PRAGMA_ACC_CLAUSE_PRESENT_OR_COPY)\
+		| (1u << PRAGMA_ACC_CLAUSE_PRESENT_OR_COPYIN)\
+		| (1u << PRAGMA_ACC_CLAUSE_PRESENT_OR_COPYOUT)\
+		| (1u << PRAGMA_ACC_CLAUSE_PRESENT_OR_CREATE)\
+		| (1u << PRAGMA_ACC_CLAUSE_DEVICEPTR))
+
+
+/* OpenACC 1.0:
+ * Mask for data clauses
+*/
+#define ACC_DATA_CLAUSE_MASK \
+		( (1u << PRAGMA_ACC_CLAUSE_IF)\
+		| (1u << PRAGMA_ACC_CLAUSE_COPY)\
+		| (1u << PRAGMA_ACC_CLAUSE_COPYIN)\
+		| (1u << PRAGMA_ACC_CLAUSE_COPYOUT)\
+		| (1u << PRAGMA_ACC_CLAUSE_CREATE)\
+		| (1u << PRAGMA_ACC_CLAUSE_PRESENT)\
+		| (1u << PRAGMA_ACC_CLAUSE_PRESENT_OR_COPY)\
+		| (1u << PRAGMA_ACC_CLAUSE_PRESENT_OR_COPYIN)\
+		| (1u << PRAGMA_ACC_CLAUSE_PRESENT_OR_COPYOUT)\
+		| (1u << PRAGMA_ACC_CLAUSE_PRESENT_OR_CREATE)\
+		| (1u << PRAGMA_ACC_CLAUSE_DEVICEPTR))
+
+/* OpenACC 1.0:
+ * Mask for host_data clauses
+*/
+#define ACC_HOST_DATA_CLAUSE_MASK \
+		( (1u << PRAGMA_ACC_CLAUSE_USE_DEVICE))
+
+
+/* OpenACC 1.0:
+ * Mask for loop clauses
+*/
+#define ACC_LOOP_CLAUSE_MASK \
+		(  (1u << PRAGMA_ACC_CLAUSE_COLLAPSE)\
+		| (1u << PRAGMA_ACC_CLAUSE_GANG)\
+		| (1u << PRAGMA_ACC_CLAUSE_WORKER)\
+		| (1u << PRAGMA_ACC_CLAUSE_VECTOR)\
+		| (1u << PRAGMA_ACC_CLAUSE_SEQ)\
+		| (1u << PRAGMA_ACC_CLAUSE_INDEPENDENT)\
+		| (1u << PRAGMA_ACC_CLAUSE_PRIVATE)\
+		| (1u << PRAGMA_ACC_CLAUSE_REDUCTION))
+
+/* OpenACC 1.0:
+ * Mask for declare clauses
+*/
+#define ACC_DECLARE_CLAUSE_MASK \
+		( (1u << PRAGMA_ACC_CLAUSE_COPY)\
+		| (1u << PRAGMA_ACC_CLAUSE_COPYIN)\
+		| (1u << PRAGMA_ACC_CLAUSE_COPYOUT)\
+		| (1u << PRAGMA_ACC_CLAUSE_CREATE)\
+		| (1u << PRAGMA_ACC_CLAUSE_PRESENT)\
+		| (1u << PRAGMA_ACC_CLAUSE_PRESENT_OR_COPY)\
+		| (1u << PRAGMA_ACC_CLAUSE_PRESENT_OR_COPYIN)\
+		| (1u << PRAGMA_ACC_CLAUSE_PRESENT_OR_COPYOUT)\
+		| (1u << PRAGMA_ACC_CLAUSE_PRESENT_OR_CREATE)\
+		| (1u << PRAGMA_ACC_CLAUSE_DEVICEPTR)\
+		| (1u << PRAGMA_ACC_CLAUSE_DEVICE_RESIDENT))
+
+/* OpenACC 1.0:
+ * Mask for update clauses
+*/
+#define ACC_UPDATE_CLAUSE_MASK \
+		( (1u << PRAGMA_ACC_CLAUSE_HOST)\
+		| (1u << PRAGMA_ACC_CLAUSE_DEVICE)\
+		| (1u << PRAGMA_ACC_CLAUSE_IF)\
+		| (1u << PRAGMA_ACC_CLAUSE_ASYNC))
+
+extern pragma_acc_clause
+pragma_acc_clause_get_name(const char* p, pragma_acc_clause result);
+
 extern struct cpp_reader* parse_in;
 
 /* It's safe to always leave visibility pragma enabled as if
diff --git a/gcc/c-family/c.opt b/gcc/c-family/c.opt
index 24d1b87d11f..c906e3c9533 100644
--- a/gcc/c-family/c.opt
+++ b/gcc/c-family/c.opt
@@ -1077,6 +1077,10 @@ fopenmp
 C ObjC C++ ObjC++ Var(flag_openmp)
 Enable OpenMP (implies -frecursive in Fortran)
 
+fopenacc
+C C++ Var(flag_openacc)
+Enable OpenACC
+
 foperator-names
 C++ ObjC++
 Recognize C++ keywords like \"compl\" and \"xor\"
diff --git a/gcc/c/c-parser.c b/gcc/c/c-parser.c
index b612e29c852..3077423fe69 100644
--- a/gcc/c/c-parser.c
+++ b/gcc/c/c-parser.c
@@ -1186,6 +1186,20 @@ static void c_parser_omp_flush (c_parser *);
 static void c_parser_omp_taskwait (c_parser *);
 static void c_parser_omp_taskyield (c_parser *);
 
+/* Declaration of main OpenACC parsing routines */
+static void c_parser_acc_construct (c_parser *);
+static tree c_parser_acc_all_clauses (c_parser *, unsigned int, const char *);
+
+static tree c_parser_acc_cache (location_t, c_parser *);
+static tree c_parser_acc_data(location_t, c_parser *);
+static tree c_parser_acc_declare (location_t, c_parser *);
+static tree c_parser_acc_host_data (location_t, c_parser *);
+static tree c_parser_acc_kernels (location_t, c_parser *);
+static tree c_parser_acc_loop (location_t, c_parser *);
+static tree c_parser_acc_parallel (location_t, c_parser *);
+static tree c_parser_acc_update (location_t, c_parser *);
+
+
 enum pragma_context { pragma_external, pragma_stmt, pragma_compound };
 static bool c_parser_pragma (c_parser *, enum pragma_context);
 
@@ -8962,7 +8976,19 @@ c_parser_pragma (c_parser *parser, enum pragma_context context)
 	      c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
 	      return false;
 	    }
-	  c_parser_omp_construct (parser);
+
+          /* Process OpenMP pragmas only */
+          if (id >= PRAGMA_OMP_ATOMIC && id <= PRAGMA_OMP_THREADPRIVATE)
+          {
+            c_parser_omp_construct (parser);
+          }
+
+          /* Process OpenACC pragmas only */
+          if (id >= PRAGMA_ACC_PARALLEL && id <= PRAGMA_ACC_UPDATE)
+          {
+            c_parser_acc_construct (parser);
+          }
+
 	  return true;
 	}
       break;
@@ -10922,6 +10948,7 @@ c_parser_omp_construct (c_parser *parser)
     case PRAGMA_OMP_TASK:
       stmt = c_parser_omp_task (loc, parser);
       break;
+
     default:
       gcc_unreachable ();
     }
@@ -10985,6 +11012,1254 @@ c_parser_omp_threadprivate (c_parser *parser)
   c_parser_skip_to_pragma_eol (parser);
 }
 
+/********************* Begin of OpenACC parsing routines **********************/
+/******************************************************************************/
+
+/* Returns name of the next clause.
+   If the clause is not recognized PRAGMA_ACC_CLAUSE_NONE is returned and
+   the token is not consumed. Otherwise appropriate pragma clause is
+   returned and the token is consumed. */
+static pragma_acc_clause
+c_parser_acc_clause_name (c_parser *parser)
+{
+  pragma_acc_clause result = PRAGMA_ACC_CLAUSE_NONE;
+
+  if (c_parser_next_token_is_keyword (parser, RID_IF))
+  {
+    result = PRAGMA_ACC_CLAUSE_IF;
+  }
+  else if (c_parser_next_token_is (parser, CPP_NAME))
+  {
+    const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
+    result = pragma_acc_clause_get_name(p, result);
+  }
+
+  if (result != PRAGMA_ACC_CLAUSE_NONE)
+  {
+    c_parser_consume_token (parser);
+  }
+
+  return result;
+}
+
+/* Validate that a clause of the given type does not already exist.  */
+static void
+c_parser_acc_clause_check_no_duplicate (tree clauses,
+                                        enum acc_clause_code code,
+                                        const char *name)
+{
+  tree c;
+
+  for (c = clauses; c ; c = ACC_CLAUSE_CHAIN (c))
+  {
+    if (ACC_CLAUSE_CODE (c) == code)
+    {
+      location_t loc = ACC_CLAUSE_LOCATION (c);
+      error_at (loc, "too many %qs clauses", name);
+      break;
+    }
+  }
+}
+
+/* OpenACC 1.0:
+   variable-list:
+     identifier
+     variable-list , identifier  */
+static tree
+c_parser_acc_variable_list (c_parser *parser,
+                            location_t clause_loc,
+                            enum acc_clause_code kind,
+                            tree list)
+{
+  if (c_parser_next_token_is_not (parser, CPP_NAME) ||
+      c_parser_peek_token (parser)->id_kind != C_ID_ID)
+  {
+    c_parser_error (parser, "expected identifier");
+  }
+
+  while (c_parser_next_token_is (parser, CPP_NAME) &&
+         c_parser_peek_token (parser)->id_kind == C_ID_ID)
+  {
+    tree t_name = lookup_name (c_parser_peek_token (parser)->value);
+
+    if (t_name == NULL_TREE)
+    {
+      undeclared_variable (c_parser_peek_token (parser)->location,
+                           c_parser_peek_token (parser)->value);
+    }
+    else if (kind != 0)
+    {
+      tree new_clause = build_acc_clause (clause_loc, kind);
+      ACC_CLAUSE_DECL (new_clause) = t_name;
+      ACC_CLAUSE_CHAIN (new_clause) = list;
+
+      list = new_clause;
+    }
+    else
+    {
+      list = tree_cons (t_name, NULL_TREE, list);
+    }
+
+    c_parser_consume_token (parser);
+
+    if (c_parser_next_token_is_not (parser, CPP_COMMA))
+    {
+      break;
+    }
+
+    c_parser_consume_token (parser);
+  }
+
+  return list;
+}
+
+static tree
+c_parser_acc_var_list_parens (c_parser *parser, enum acc_clause_code kind,
+                              tree list)
+{
+  location_t loc = c_parser_peek_token (parser)->location;
+
+  if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
+  {
+    list = c_parser_acc_variable_list (parser, loc, kind, list);
+    c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
+  }
+
+  return list;
+}
+
+/* OpenACC 1.0:
+   async */
+static tree
+c_parser_acc_clause_async (c_parser *parser, tree list)
+{
+  tree c;
+
+  c_parser_acc_clause_check_no_duplicate (list, ACC_CLAUSE_ASYNC,
+                                          "async");
+
+  c = build_acc_clause (c_parser_peek_token (parser)->location,
+                        ACC_CLAUSE_ASYNC);
+  ACC_CLAUSE_CHAIN (c) = list;
+
+  return c;
+}
+
+/* OpenACC 1.0:
+   seq */
+static tree
+c_parser_acc_clause_seq (c_parser *parser, tree list)
+{
+  tree c;
+
+  c_parser_acc_clause_check_no_duplicate (list, ACC_CLAUSE_SEQ,
+                                          "seq");
+
+  c = build_acc_clause (c_parser_peek_token (parser)->location,
+                        ACC_CLAUSE_SEQ);
+  ACC_CLAUSE_CHAIN (c) = list;
+
+  return c;
+}
+
+/* OpenACC 1.0:
+   independent */
+static tree
+c_parser_acc_clause_independent (c_parser *parser, tree list)
+{
+  tree c;
+
+  c_parser_acc_clause_check_no_duplicate (list, ACC_CLAUSE_INDEPENDENT,
+                                          "independent");
+
+  c = build_acc_clause (c_parser_peek_token (parser)->location,
+                        ACC_CLAUSE_INDEPENDENT);
+  ACC_CLAUSE_CHAIN (c) = list;
+
+  return c;
+}
+
+/* OpenACC 1.0:
+   if ( expression ) */
+static tree
+c_parser_acc_clause_if (c_parser *parser, tree list)
+{
+  location_t loc = c_parser_peek_token (parser)->location;
+  if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
+  {
+    tree t = c_parser_paren_condition (parser);
+    tree c;
+
+    c_parser_acc_clause_check_no_duplicate (list, ACC_CLAUSE_IF, "if");
+
+    c = build_acc_clause (loc, ACC_CLAUSE_IF);
+
+    ACC_CLAUSE_IF_EXPR (c) = t;
+    ACC_CLAUSE_CHAIN (c) = list;
+    list = c;
+  }
+  else
+  {
+    c_parser_error (parser, "expected %<(%>");
+  }
+
+  return list;
+}
+
+
+/* OpenACC 1.0:
+   collapse ( constant-expression ) */
+static tree
+c_parser_acc_clause_collapse (c_parser *parser, tree list)
+{
+  tree c, num = error_mark_node;
+  HOST_WIDE_INT n;
+  location_t loc = c_parser_peek_token (parser)->location;
+
+  c_parser_acc_clause_check_no_duplicate(list, ACC_CLAUSE_COLLAPSE,
+                                         "collapse");
+
+  if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
+  {
+    num = c_parser_expr_no_commas (parser, NULL).value;
+    c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
+  }
+  
+  if (num == error_mark_node)
+  {
+    return list;
+  }
+  
+  if (!INTEGRAL_TYPE_P (TREE_TYPE (num))
+      || !host_integerp (num, 0)
+      || (n = tree_low_cst (num, 0)) <= 0
+      || (int) n != n)
+  {
+    error_at (loc,
+    "collapse argument needs positive constant integer expression");
+    return list;
+  }
+  
+  c = build_acc_clause (loc, ACC_CLAUSE_COLLAPSE);
+  ACC_CLAUSE_COLLAPSE_EXPR (c) = num;
+  ACC_CLAUSE_CHAIN (c) = list;
+
+  return c;
+}
+
+/* OpenACC 1.0:
+   num_gangs ( expression ) */
+static tree
+c_parser_acc_clause_num_gangs (c_parser *parser, tree list)
+{
+  location_t loc = c_parser_peek_token (parser)->location;
+
+  if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
+  {
+    location_t expr_loc = c_parser_peek_token (parser)->location;
+    tree c, t = c_parser_expression (parser).value;
+    mark_exp_read (t);
+    t = c_fully_fold (t, false, NULL);
+
+    c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
+
+    if (!INTEGRAL_TYPE_P (TREE_TYPE (t)))
+    {
+      c_parser_error (parser, "expected integer expression");
+      return list;
+    }
+
+    /* Attempt to statically determine when the number isn't positive.  */
+    c = fold_build2_loc (expr_loc, LE_EXPR, boolean_type_node, t,
+                         build_int_cst (TREE_TYPE (t), 0));
+    if (CAN_HAVE_LOCATION_P (c))
+    {
+      SET_EXPR_LOCATION (c, expr_loc);
+    }
+
+    if (c == boolean_true_node)
+    {
+      warning_at (expr_loc, 0,
+                  "%<num_gangs%> value must be positive");
+      t = integer_one_node;
+    }
+
+    c_parser_acc_clause_check_no_duplicate (list, ACC_CLAUSE_NUM_GANGS,
+                                            "num_gangs");
+
+    c = build_acc_clause (loc, ACC_CLAUSE_NUM_GANGS);
+    ACC_CLAUSE_NUM_GANGS_EXPR (c) = t;
+    ACC_CLAUSE_CHAIN (c) = list;
+    list = c;
+  }
+
+  return list;
+}
+
+/* OpenACC 1.0:
+   vector_length ( expression ) */
+static tree
+c_parser_acc_clause_vector_length (c_parser *parser, tree list)
+{
+  location_t loc = c_parser_peek_token (parser)->location;
+
+  if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
+  {
+    location_t expr_loc = c_parser_peek_token (parser)->location;
+    tree c, t = c_parser_expression (parser).value;
+    mark_exp_read (t);
+    t = c_fully_fold (t, false, NULL);
+
+    c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
+
+    if (!INTEGRAL_TYPE_P (TREE_TYPE (t)))
+    {
+      c_parser_error (parser, "expected integer expression");
+      return list;
+    }
+
+    /* Attempt to statically determine when the number isn't positive.  */
+    c = fold_build2_loc (expr_loc, LE_EXPR, boolean_type_node, t,
+                         build_int_cst (TREE_TYPE (t), 0));
+    if (CAN_HAVE_LOCATION_P (c))
+    {
+      SET_EXPR_LOCATION (c, expr_loc);
+    }
+
+    if (c == boolean_true_node)
+    {
+      warning_at (expr_loc, 0,
+                  "%<vector_length%> value must be positive");
+      t = integer_one_node;
+    }
+
+    c_parser_acc_clause_check_no_duplicate (list, ACC_CLAUSE_NUM_GANGS, "num_gangs");
+
+    c = build_acc_clause (loc, ACC_CLAUSE_VECTOR_LENGTH);
+    ACC_CLAUSE_VECTOR_LENGTH_EXPR (c) = t;
+    ACC_CLAUSE_CHAIN (c) = list;
+    list = c;
+  }
+
+  return list;
+}
+
+/* OpenACC 1.0:
+   num_workers ( expression ) */
+static tree
+c_parser_acc_clause_num_workers (c_parser *parser, tree list)
+{
+  location_t loc = c_parser_peek_token (parser)->location;\
+
+  if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
+  {
+    location_t expr_loc = c_parser_peek_token (parser)->location;
+    tree c, t = c_parser_expression (parser).value;
+    mark_exp_read (t);
+    t = c_fully_fold (t, false, NULL);
+
+    c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
+
+    if (!INTEGRAL_TYPE_P (TREE_TYPE (t)))
+    {
+      c_parser_error (parser, "expected integer expression");
+      return list;
+    }
+
+    /* Attempt to statically determine when the number isn't positive.  */
+    c = fold_build2_loc (expr_loc, LE_EXPR, boolean_type_node, t,
+                         build_int_cst (TREE_TYPE (t), 0));
+    if (CAN_HAVE_LOCATION_P (c))
+    {
+      SET_EXPR_LOCATION (c, expr_loc);
+    }
+
+    if (c == boolean_true_node)
+    {
+      warning_at (expr_loc, 0,
+                  "%<num_workers%> value must be positive");
+      t = integer_one_node;
+    }
+
+    c_parser_acc_clause_check_no_duplicate (list,
+                                            ACC_CLAUSE_NUM_WORKERS,
+                                            "num_workers");
+
+    c = build_acc_clause (loc, ACC_CLAUSE_NUM_WORKERS);
+    ACC_CLAUSE_NUM_WORKERS_EXPR (c) = t;
+    ACC_CLAUSE_CHAIN (c) = list;
+    list = c;
+  }
+
+  return list;
+}
+
+/* OpenACC 1.0:
+   reduction ( reduction-operator : variable-list )
+
+   reduction-operator:
+     One of: + * - & ^ | && || max min  */
+
+static tree
+c_parser_acc_clause_reduction (c_parser *parser, tree list)
+{
+  location_t clause_loc = c_parser_peek_token (parser)->location;
+
+  if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
+  {
+    enum tree_code code;
+
+    switch (c_parser_peek_token (parser)->type)
+    {
+    case CPP_PLUS:
+      code = PLUS_EXPR;
+      break;
+    case CPP_MULT:
+      code = MULT_EXPR;
+      break;
+    case CPP_MINUS:
+      code = MINUS_EXPR;
+      break;
+    case CPP_AND:
+      code = BIT_AND_EXPR;
+      break;
+    case CPP_XOR:
+      code = BIT_XOR_EXPR;
+      break;
+    case CPP_OR:
+      code = BIT_IOR_EXPR;
+      break;
+    case CPP_AND_AND:
+      code = TRUTH_ANDIF_EXPR;
+      break;
+    case CPP_OR_OR:
+      code = TRUTH_ORIF_EXPR;
+      break;
+    case CPP_NAME:
+    {
+      const char *p
+        = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
+      if (strcmp (p, "min") == 0)
+      {
+        code = MIN_EXPR;
+        break;
+      }
+      if (strcmp (p, "max") == 0)
+      {
+        code = MAX_EXPR;
+        break;
+      }
+    }
+    /* FALLTHRU */
+    default:
+      c_parser_error (parser,
+                      "expected %<+%>, %<*%>, %<-%>, %<&%>, "
+                      "%<^%>, %<|%>, %<&&%>, %<||%>, %<min%> or %<max%>");
+      c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 0);
+      return list;
+    }
+
+    c_parser_consume_token (parser);
+    if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
+    {
+      tree nl, c;
+
+      nl = c_parser_acc_variable_list (parser, clause_loc,
+                                       ACC_CLAUSE_REDUCTION, list);
+      for (c = nl; c != list; c = ACC_CLAUSE_CHAIN (c))
+      {
+        ACC_CLAUSE_REDUCTION_CODE (c) = code;
+      }
+
+      list = nl;
+    }
+    c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
+  }
+  return list;
+}
+
+/* Parse all OpenACC clauses. The set clauses allowed by the directive
+   is a bitmask in MASK. Return the list of clauses found; the result
+   of clause default goes in *pdefault.  */
+static tree
+c_parser_acc_all_clauses (c_parser *parser, unsigned int mask,
+                          const char *where)
+{
+  tree clauses = NULL;
+  bool first = true;
+
+  while (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
+  {
+    location_t here;
+    pragma_acc_clause c_kind;
+    const char *c_name;
+    tree prev = clauses;
+
+    if (!first && c_parser_next_token_is (parser, CPP_COMMA))
+  	  c_parser_consume_token (parser);
+
+    first = false;
+    here = c_parser_peek_token (parser)->location;
+    c_kind = c_parser_acc_clause_name (parser);
+
+    switch (c_kind)
+    {
+      /* Done */
+    case PRAGMA_ACC_CLAUSE_NUM_GANGS:
+      clauses = c_parser_acc_clause_num_gangs (parser, clauses);
+      c_name = "num_gangs";
+      break;
+    case PRAGMA_ACC_CLAUSE_NUM_WORKERS:
+      clauses = c_parser_acc_clause_num_workers (parser, clauses);
+      c_name = "num_workers";
+      break;
+    case PRAGMA_ACC_CLAUSE_VECTOR_LENGTH:
+      clauses = c_parser_acc_clause_vector_length (parser, clauses);
+      c_name = "vector_length";
+      break;
+    case PRAGMA_ACC_CLAUSE_IF:
+      clauses = c_parser_acc_clause_if (parser, clauses);
+      c_name = "if";
+      break;
+    case PRAGMA_ACC_CLAUSE_SEQ:
+      clauses = c_parser_acc_clause_seq (parser, clauses);
+      c_name = "seq";
+      break;
+    case PRAGMA_ACC_CLAUSE_INDEPENDENT:
+      clauses = c_parser_acc_clause_independent (parser, clauses);
+      c_name = "independent";
+      break;
+    case PRAGMA_ACC_CLAUSE_ASYNC:
+      clauses = c_parser_acc_clause_async (parser, clauses);
+      c_name = "async";
+      break;
+    case PRAGMA_ACC_CLAUSE_COLLAPSE:
+      clauses = c_parser_acc_clause_collapse (parser, clauses);
+      c_name = "collapse";
+      break;
+    case PRAGMA_ACC_CLAUSE_REDUCTION:
+      clauses = c_parser_acc_clause_reduction (parser, clauses);
+      c_name = "reduction";
+      break;
+    case PRAGMA_ACC_CLAUSE_COPY:
+      clauses = c_parser_acc_var_list_parens (parser,
+                                              ACC_CLAUSE_COPY,
+                                              clauses);
+      c_name = "copy";
+      break;
+    case PRAGMA_ACC_CLAUSE_COPYIN:
+      clauses = c_parser_acc_var_list_parens (parser,
+                                              ACC_CLAUSE_COPYIN,
+                                              clauses);
+      c_name = "copyin";
+      break;
+    case PRAGMA_ACC_CLAUSE_COPYOUT:
+      clauses = c_parser_acc_var_list_parens (parser,
+                                              ACC_CLAUSE_COPYOUT,
+                                              clauses);
+      c_name = "copyout";
+      break;
+    case PRAGMA_ACC_CLAUSE_PRESENT_OR_COPY:
+      clauses = c_parser_acc_var_list_parens (parser,
+                                              ACC_CLAUSE_PRESENT_OR_COPY,
+                                              clauses);
+      c_name = "present_or_copy";
+      break;
+    case PRAGMA_ACC_CLAUSE_PRESENT_OR_COPYIN:
+      clauses = c_parser_acc_var_list_parens (parser,
+                                              ACC_CLAUSE_PRESENT_OR_COPYIN,
+                                              clauses);
+      c_name = "present_or_copyin";
+      break;
+    case PRAGMA_ACC_CLAUSE_PRESENT_OR_COPYOUT:
+      clauses = c_parser_acc_var_list_parens (parser,
+                                              ACC_CLAUSE_PRESENT_OR_COPYOUT,
+                                              clauses);
+      c_name = "present_or_copyout";
+      break;
+    case PRAGMA_ACC_CLAUSE_PRIVATE:
+      clauses = c_parser_acc_var_list_parens (parser,
+                                              ACC_CLAUSE_PRIVATE,
+                                              clauses);
+      c_name = "private";
+      break;
+    case PRAGMA_ACC_CLAUSE_FIRSTPRIVATE:
+      clauses = c_parser_acc_var_list_parens (parser,
+                                              ACC_CLAUSE_FIRSTPRIVATE,
+                                              clauses);
+      c_name = "firstprivate";
+      break;
+    case PRAGMA_ACC_CLAUSE_PRESENT:
+      clauses = c_parser_acc_var_list_parens (parser,
+                                              ACC_CLAUSE_PRESENT,
+                                              clauses);
+      c_name = "present";
+      break;
+    case PRAGMA_ACC_CLAUSE_CREATE:
+      clauses = c_parser_acc_var_list_parens (parser,
+                                              ACC_CLAUSE_CREATE,
+                                              clauses);
+      c_name = "create";
+      break;
+    case PRAGMA_ACC_CLAUSE_PRESENT_OR_CREATE:
+      clauses = c_parser_acc_var_list_parens (parser,
+                                              ACC_CLAUSE_PRESENT_OR_CREATE,
+                                              clauses);
+      c_name = "present_or_create";
+      break;
+    case PRAGMA_ACC_CLAUSE_DEVICEPTR:
+      clauses = c_parser_acc_var_list_parens (parser,
+                                              ACC_CLAUSE_DEVICEPTR,
+                                              clauses);
+      c_name = "deviceptr";
+      break;
+    case PRAGMA_ACC_CLAUSE_GANG:
+      clauses = c_parser_acc_var_list_parens (parser,
+                                              ACC_CLAUSE_GANG,
+                                              clauses);
+      c_name = "gang";
+      break;
+    case PRAGMA_ACC_CLAUSE_WORKER:
+      clauses = c_parser_acc_var_list_parens (parser,
+                                              ACC_CLAUSE_WORKER,
+                                              clauses);
+      c_name = "worker";
+      break;
+    case PRAGMA_ACC_CLAUSE_VECTOR:
+      clauses = c_parser_acc_var_list_parens (parser,
+                                              ACC_CLAUSE_VECTOR,
+                                              clauses);
+      break;
+      /* Undone - TODO Do not know how it should look like.
+
+    case PRAGMA_ACC_CLAUSE_HOST:
+      clauses = c_parser_acc_clause_host (parser, clauses);
+      c_name = "host";
+      break;
+    case PRAGMA_ACC_CLAUSE_DEVICE:
+      clauses = c_parser_acc_clause_device (parser, clauses);
+      c_name = "device";
+      break;
+    case PRAGMA_ACC_CLAUSE_DEVICE_RESIDENT:
+      clauses = c_parser_acc_clause_resident (parser, clauses);
+      c_name = "resident";
+      break;
+    case PRAGMA_ACC_CLAUSE_USE_DEVICE:
+      clauses = c_parser_acc_clause_use_device (parser, clauses);
+      c_name = "device";
+      break;*/
+
+    default:
+      c_parser_error (parser, "expected %<#pragma acc%> clause");
+      goto saw_error;
+    }
+
+    if (((mask >> c_kind) & 1) == 0 && !parser->error)
+    {
+      /* Remove the invalid clause(s) from the list to avoid
+         confusing the rest of the compiler.  */
+      clauses = prev;
+      error_at (here, "%qs is not valid for %qs", c_name, where);
+    }
+  }
+
+ saw_error:
+  c_parser_skip_to_pragma_eol (parser);
+
+  return clauses;
+  //return c_finish_acc_clauses (clauses); // validate and remove the brokens
+}
+
+/* Like c_begin_compound_stmt, except force the retention of the BLOCK.
+ */
+tree
+c_begin_acc_parallel (void)
+{
+  tree block;
+
+  keep_next_level ();
+  block = c_begin_compound_stmt (true);
+
+  return block;
+}
+
+/* Like c_begin_compound_stmt, except force the retention of the BLOCK.
+ */
+tree
+c_begin_acc_kernels (void)
+{
+  tree block;
+
+  keep_next_level ();
+  block = c_begin_compound_stmt (true);
+
+  return block;
+}
+
+/* Generate ACC_PARALLEL, with CLAUSES and BLOCK as its compound
+   statement. */
+tree
+c_finish_acc_parallel (location_t loc, tree clauses, tree block)
+{
+  tree stmt;
+
+  block = c_end_compound_stmt (loc, block, true);
+
+  stmt = make_node (ACC_PARALLEL);
+  TREE_TYPE (stmt) = void_type_node;
+  ACC_PARALLEL_CLAUSES (stmt) = clauses;
+  ACC_PARALLEL_BODY (stmt) = block;
+  SET_EXPR_LOCATION (stmt, loc);
+
+  return add_stmt (stmt);
+}
+
+/* Generate ACC_KERNELS, with CLAUSES and BLOCK as its compound
+   statement. */
+tree
+c_finish_acc_kernels (location_t loc, tree clauses, tree block)
+{
+  tree stmt;
+
+  block = c_end_compound_stmt (loc, block, true);
+
+  stmt = make_node (ACC_KERNELS);
+  TREE_TYPE (stmt) = void_type_node;
+  ACC_KERNELS_CLAUSES (stmt) = clauses;
+  ACC_KERNELS_BODY (stmt) = block;
+  SET_EXPR_LOCATION (stmt, loc);
+
+  return add_stmt (stmt);
+}
+
+/* OpenACC 1.0:
+   # pragma parallel parallel-clause new-line
+   # pragma parallel for parallel-for-clause new-line
+
+   LOC is the location of the #pragma token.
+*/
+static tree
+c_parser_acc_parallel (location_t loc, c_parser *parser)
+{
+  enum pragma_kind p_kind = PRAGMA_ACC_PARALLEL;
+  const char *p_name = "#pragma acc parallel";
+  tree stmt, clauses, block;
+  unsigned int mask = ACC_PARALLEL_CLAUSE_MASK;
+
+/* TODO FIX ERROR
+ *   const char *next_token = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
+  if (!strcmp(next_token, "loop"))
+    {
+      c_parser_consume_token (parser);
+      p_kind = PRAGMA_ACC_PARALLEL_LOOP;
+      p_name = "#pragma acc parallel loop";
+      mask |= ACC_LOOP_CLAUSE_MASK;
+    }
+*/
+
+  clauses = c_parser_acc_all_clauses (parser, mask, p_name);
+
+  switch (p_kind)
+  {
+  case PRAGMA_ACC_PARALLEL:
+    block = c_begin_acc_parallel ();
+    c_parser_statement (parser);
+    stmt = c_finish_acc_parallel (loc, clauses, block);
+    break;
+
+  default:
+    gcc_unreachable ();
+  }
+
+  return stmt;
+}
+
+/*
+ * OpenACC 1.0
+ * Kernels pragma
+ * */
+static tree
+c_parser_acc_kernels (location_t loc, c_parser *parser)
+{
+  enum pragma_kind p_kind = PRAGMA_ACC_KERNELS;
+  const char *p_name = "#pragma acc kernels";
+  tree stmt, clauses, block;
+  unsigned int mask = ACC_KERNELS_CLAUSE_MASK;
+
+  /* TODO FIX ERROR
+   * const char *next_token = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
+  if (!strcmp(next_token, "loop"))
+    {
+      c_parser_consume_token (parser);
+      p_kind = PRAGMA_ACC_KERNELS_LOOP;
+      p_name = "#pragma acc kernels loop";
+      mask |= ACC_LOOP_CLAUSE_MASK;
+    }
+*/
+  clauses = c_parser_acc_all_clauses (parser, mask, p_name);
+
+  switch (p_kind)
+  {
+  case PRAGMA_ACC_KERNELS:
+    block = c_begin_acc_kernels ();
+    c_parser_statement (parser);
+    stmt = c_finish_acc_kernels (loc, clauses, block);
+    break;
+
+  default:
+    gcc_unreachable ();
+  }
+
+  return stmt;
+}
+
+static tree
+c_parser_acc_loop_1 (location_t loc,
+                     c_parser *parser,
+                     tree clauses,
+                     tree *par_clauses)
+{
+  tree decl, cond, incr, save_break, save_cont, body, init, stmt, cl;
+  tree declv, condv, incrv, initv, ret = NULL;
+  bool fail = false, open_brace_parsed = false;
+  int i, collapse = 1, nbraces = 0;
+  location_t for_loc;
+  vec<tree, va_gc> *for_block = make_tree_vector ();
+
+  for (cl = clauses; cl; cl = ACC_CLAUSE_CHAIN (cl))
+  {
+    if (ACC_CLAUSE_CODE (cl) == ACC_CLAUSE_COLLAPSE)
+    {
+      collapse = tree_low_cst (ACC_CLAUSE_COLLAPSE_EXPR (cl), 0);
+    }
+  }
+
+  gcc_assert (collapse >= 1);
+
+  declv = make_tree_vec (collapse);
+  initv = make_tree_vec (collapse);
+  condv = make_tree_vec (collapse);
+  incrv = make_tree_vec (collapse);
+
+  if (!c_parser_next_token_is_keyword (parser, RID_FOR))
+  {
+    c_parser_error (parser, "for statement expected");
+    return NULL;
+  }
+
+  for_loc = c_parser_peek_token (parser)->location;
+  c_parser_consume_token (parser);
+
+  for (i = 0; i < collapse; i++)
+  {
+    int bracecount = 0;
+
+    if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
+      goto pop_scopes;
+
+    /* Parse the initialization declaration or expression.  */
+    if (c_parser_next_tokens_start_declaration (parser))
+      {
+        if (i > 0)
+          vec_safe_push (for_block, c_begin_compound_stmt (true));
+        c_parser_declaration_or_fndef (parser, true, true, true, true, true, NULL);
+        decl = check_for_loop_decls (for_loc, flag_isoc99);
+        if (decl == NULL)
+          goto error_init;
+        if (DECL_INITIAL (decl) == error_mark_node)
+          decl = error_mark_node;
+        init = decl;
+      }
+    else if (c_parser_next_token_is (parser, CPP_NAME)
+             && c_parser_peek_2nd_token (parser)->type == CPP_EQ)
+      {
+        struct c_expr decl_exp;
+        struct c_expr init_exp;
+        location_t init_loc;
+
+        decl_exp = c_parser_postfix_expression (parser);
+        decl = decl_exp.value;
+
+        c_parser_require (parser, CPP_EQ, "expected %<=%>");
+
+        init_loc = c_parser_peek_token (parser)->location;
+        init_exp = c_parser_expr_no_commas (parser, NULL);
+        init_exp = default_function_array_read_conversion (init_loc,
+                                                           init_exp);
+        init = build_modify_expr (init_loc, decl, decl_exp.original_type,
+                                  NOP_EXPR, init_loc, init_exp.value,
+                                  init_exp.original_type);
+        init = c_process_expr_stmt (init_loc, init);
+
+        c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
+      }
+    else
+      {
+      error_init:
+        c_parser_error (parser,
+                        "expected iteration declaration or initialization");
+        c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
+                                   "expected %<)%>");
+        fail = true;
+        goto parse_next;
+      }
+
+    /* Parse the loop condition.  */
+    cond = NULL_TREE;
+    if (c_parser_next_token_is_not (parser, CPP_SEMICOLON))
+      {
+        location_t cond_loc = c_parser_peek_token (parser)->location;
+        struct c_expr cond_expr = c_parser_binary_expression (parser, NULL,
+                                                              PREC_NONE);
+
+        cond = cond_expr.value;
+        cond = c_objc_common_truthvalue_conversion (cond_loc, cond);
+        cond = c_fully_fold (cond, false, NULL);
+        switch (cond_expr.original_code)
+          {
+          case GT_EXPR:
+          case GE_EXPR:
+          case LT_EXPR:
+          case LE_EXPR:
+            break;
+          default:
+            /* Can't be cond = error_mark_node, because we want to preserve
+               the location until c_finish_omp_for.  */
+            cond = build1 (NOP_EXPR, boolean_type_node, error_mark_node);
+            break;
+          }
+        protected_set_expr_location (cond, cond_loc);
+      }
+    c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
+
+    /* Parse the increment expression.  */
+    incr = NULL_TREE;
+    if (c_parser_next_token_is_not (parser, CPP_CLOSE_PAREN))
+      {
+        location_t incr_loc = c_parser_peek_token (parser)->location;
+
+        incr = c_process_expr_stmt (incr_loc,
+                                    c_parser_expression (parser).value);
+      }
+    c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
+
+    if (decl == NULL || decl == error_mark_node || init == error_mark_node)
+      fail = true;
+    else
+      {
+        TREE_VEC_ELT (declv, i) = decl;
+        TREE_VEC_ELT (initv, i) = init;
+        TREE_VEC_ELT (condv, i) = cond;
+        TREE_VEC_ELT (incrv, i) = incr;
+      }
+
+  parse_next:
+    if (i == collapse - 1)
+      break;
+
+    do
+      {
+        if (c_parser_next_token_is_keyword (parser, RID_FOR))
+          {
+            c_parser_consume_token (parser);
+            break;
+          }
+        else if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
+          {
+            c_parser_consume_token (parser);
+            bracecount++;
+          }
+        else if (bracecount
+                 && c_parser_next_token_is (parser, CPP_SEMICOLON))
+          c_parser_consume_token (parser);
+        else
+          {
+            c_parser_error (parser, "not enough perfectly nested loops");
+            if (bracecount)
+              {
+                open_brace_parsed = true;
+                bracecount--;
+              }
+            fail = true;
+            collapse = 0;
+            break;
+          }
+      }
+    while (1);
+
+    nbraces += bracecount;
+  }
+
+  save_break = c_break_label;
+  c_break_label = size_one_node;
+  save_cont = c_cont_label;
+  c_cont_label = NULL_TREE;
+  body = push_stmt_list ();
+
+  if (open_brace_parsed)
+    {
+      location_t here = c_parser_peek_token (parser)->location;
+      stmt = c_begin_compound_stmt (true);
+      c_parser_compound_statement_nostart (parser);
+      add_stmt (c_end_compound_stmt (here, stmt, true));
+    }
+  else
+    add_stmt (c_parser_c99_block_statement (parser));
+  if (c_cont_label)
+    {
+      tree t = build1 (LABEL_EXPR, void_type_node, c_cont_label);
+      SET_EXPR_LOCATION (t, loc);
+      add_stmt (t);
+    }
+
+  body = pop_stmt_list (body);
+  c_break_label = save_break;
+  c_cont_label = save_cont;
+
+  while (nbraces)
+    {
+      if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
+        {
+          c_parser_consume_token (parser);
+          nbraces--;
+        }
+      else if (c_parser_next_token_is (parser, CPP_SEMICOLON))
+        c_parser_consume_token (parser);
+      else
+        {
+          c_parser_error (parser, "collapsed loops not perfectly nested");
+          while (nbraces)
+            {
+              location_t here = c_parser_peek_token (parser)->location;
+              stmt = c_begin_compound_stmt (true);
+              add_stmt (body);
+              c_parser_compound_statement_nostart (parser);
+              body = c_end_compound_stmt (here, stmt, true);
+              nbraces--;
+            }
+          goto pop_scopes;
+        }
+    }
+
+  /* Only bother calling c_finish_omp_for if we haven't already generated
+     an error from the initialization parsing.  */
+  if (!fail)
+  {
+    stmt = c_finish_omp_for (loc, declv, initv, condv, incrv, body, NULL);
+    if (stmt)
+    {
+      if (par_clauses != NULL)
+      {
+      }
+      ACC_LOOP_CLAUSES (stmt) = clauses;
+    }
+    ret = stmt;
+  }
+pop_scopes:
+  while (!for_block->is_empty ())
+    {
+      stmt = c_end_compound_stmt (loc, for_block->pop (), true);
+      add_stmt (stmt);
+    }
+  release_tree_vector (for_block);
+  return ret;
+}
+
+/* OpenACC 1.0:
+ *  # pragma acc loop
+ */
+static tree
+c_parser_acc_loop (location_t loc, c_parser *parser)
+{
+  tree block, clauses, ret;
+
+  clauses = c_parser_acc_all_clauses (parser,
+                                      ACC_LOOP_CLAUSE_MASK,
+                                      "#pragma acc loop");
+
+  block = c_begin_compound_stmt (true);
+  //ret = c_parser_acc_loop_1 (loc, parser, clauses, NULL);
+  block = c_end_compound_stmt (loc, block, true);
+  add_stmt (block);
+
+  return ret;
+}
+
+/* OpenACC 1.0:
+ *  # pragma acc wait (scalar expr) new-line
+ */
+static tree
+c_parser_acc_wait (location_t loc, c_parser *parser)
+{
+  enum pragma_kind p_kind = PRAGMA_ACC_WAIT;
+  const char *p_name = "#pragma acc wait";
+  tree clauses, stmt;
+
+  stmt = make_node (ACC_WAIT);
+  clauses = c_parser_acc_var_list_parens (parser,
+                                          ACC_NO_CLAUSE_WAIT,
+                                          clauses);
+
+  c_parser_skip_to_pragma_eol (parser);
+
+  TREE_TYPE (stmt) = void_type_node;
+/*  ACC_WAIT (stmt) = c_parser_acc_var_list_parens (parser,
+                                                  ACC_NO_CLAUSE_WAIT,
+                                                  clauses);*/
+  SET_EXPR_LOCATION (stmt, loc);
+
+  return add_stmt (stmt);
+}
+
+/* OpenACC 1.0:
+ *  # pragma acc update
+ */
+static tree
+c_parser_acc_update (location_t loc, c_parser *parser)
+{
+  enum pragma_kind p_kind = PRAGMA_ACC_UPDATE;
+  const char *p_name = "#pragma acc update";
+  tree clauses, stmt = make_node (ACC_UPDATE);
+  unsigned int mask = ACC_UPDATE_CLAUSE_MASK;
+
+  clauses = c_parser_acc_all_clauses (parser, mask, p_name);
+
+  TREE_TYPE (stmt) = void_type_node;
+  SET_EXPR_LOCATION (stmt, loc);
+
+  return add_stmt (stmt);
+}
+
+/* OpenACC 1.0:
+ *  # pragma acc declare
+ */
+static tree
+c_parser_acc_declare (location_t loc, c_parser *parser)
+{
+  enum pragma_kind p_kind = PRAGMA_ACC_DECLARE;
+  const char *p_name = "#pragma acc declare";
+  tree clauses, stmt = make_node (ACC_DECLARE);
+  unsigned int mask = ACC_DECLARE_CLAUSE_MASK;
+
+  clauses = c_parser_acc_all_clauses (parser, mask, p_name);
+
+  TREE_TYPE (stmt) = void_type_node;
+  SET_EXPR_LOCATION (stmt, loc);
+
+  return add_stmt (stmt);
+}
+
+/* OpenACC 1.0:
+ *  # pragma acc cache
+ */
+static tree
+c_parser_acc_cache (location_t loc, c_parser *parser)
+{
+  enum pragma_kind p_kind = PRAGMA_ACC_CACHE;
+  const char *p_name = "#pragma acc cache";
+  tree clauses, stmt = make_node (ACC_CACHE);
+
+  c_parser_skip_to_pragma_eol (parser);
+
+  TREE_TYPE (stmt) = void_type_node;
+  SET_EXPR_LOCATION (stmt, loc);
+
+  return add_stmt (stmt);
+}
+
+/* OpenACC 1.0:
+ *  # pragma acc data
+ */
+static tree
+c_parser_acc_data (location_t loc, c_parser *parser)
+{
+  enum pragma_kind p_kind = PRAGMA_ACC_DATA;
+  const char *p_name = "#pragma acc data";
+  tree clauses, stmt = make_node (ACC_DATA);
+  unsigned int mask = ACC_DATA_CLAUSE_MASK;
+
+  clauses = c_parser_acc_all_clauses (parser, mask, p_name);
+
+  TREE_TYPE (stmt) = void_type_node;
+  SET_EXPR_LOCATION (stmt, loc);
+
+  return add_stmt (stmt);
+}
+
+/* OpenACC 1.0:
+ *  # pragma acc host_data
+ */
+static tree
+c_parser_acc_host_data (location_t loc, c_parser *parser)
+{
+  enum pragma_kind p_kind = PRAGMA_ACC_HOST_DATA;
+  const char *p_name = "#pragma acc host_data";
+  tree clauses, stmt = make_node (ACC_HOST_DATA);
+  unsigned int mask = ACC_HOST_DATA_CLAUSE_MASK;
+
+  clauses = c_parser_acc_all_clauses (parser, mask, p_name);
+
+  TREE_TYPE (stmt) = void_type_node;
+  SET_EXPR_LOCATION (stmt, loc);
+
+  return add_stmt (stmt);
+}
+
+/* Main entry point for parsing of the most OpenACC pragmas
+ */
+static void
+c_parser_acc_construct (c_parser *parser)
+{
+  enum pragma_kind p_kind;
+  location_t loc;
+  tree stmt;
+
+  loc = c_parser_peek_token (parser)->location;
+  p_kind = c_parser_peek_token (parser)->pragma_kind;
+  c_parser_consume_pragma (parser);
+
+  switch (p_kind)
+  {
+  case PRAGMA_ACC_PARALLEL:
+    stmt = c_parser_acc_parallel(loc, parser);
+    break;
+  case PRAGMA_ACC_KERNELS:
+    stmt = c_parser_acc_kernels (loc, parser);
+    break;
+  case PRAGMA_ACC_WAIT:
+    stmt = c_parser_acc_wait (loc, parser);
+    break;
+  case PRAGMA_ACC_CACHE:
+    stmt = c_parser_acc_cache (loc, parser);
+    break;
+  case PRAGMA_ACC_DECLARE:
+    stmt = c_parser_acc_declare (loc, parser);
+    break;
+  case PRAGMA_ACC_DATA:
+    stmt = c_parser_acc_data (loc, parser);
+    break;
+  case PRAGMA_ACC_HOST_DATA:
+    stmt = c_parser_acc_host_data (loc, parser);
+    break;
+  case PRAGMA_ACC_LOOP:
+    stmt = c_parser_acc_loop (loc, parser);
+    break;
+  case PRAGMA_ACC_UPDATE:
+    stmt = c_parser_acc_update (loc, parser);
+    break;
+  default:
+    gcc_unreachable ();
+  }
+
+  if (stmt)
+  {
+    gcc_assert (EXPR_LOCATION (stmt) != UNKNOWN_LOCATION);
+  }
+}
+
+/********************** End of OpenACC parsing routines ***********************/
+/******************************************************************************/
+
 /* Parse a transaction attribute (GCC Extension).
 
    transaction-attribute:
diff --git a/gcc/common.opt b/gcc/common.opt
index 202e169d281..e844f8e4a09 100644
--- a/gcc/common.opt
+++ b/gcc/common.opt
@@ -1127,6 +1127,10 @@ femit-class-debug-always
 Common Report Var(flag_emit_class_debug_always) Init(0)
 Do not suppress C++ class debug information.
 
+fenable-openacc-profiling
+Common Report Var(flag_enable_openacc_profiling)
+Enable OpenACC profiling
+
 fexceptions
 Common Report Var(flag_exceptions) Optimization
 Enable exception handling
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index d7840aff89f..1d8a6ce8f0c 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -4020,6 +4020,11 @@ more_aggr_init_expr_args_p (const aggr_init_expr_arg_iterator *iter)
   TREE_TYPE (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_PRIVATE, \
 				     OMP_CLAUSE_LINEAR))
 
+/* A language-specific token attached to the OpenACC data clauses to
+   hold code (or code fragments) related to ctors, dtors, and op=.
+   See semantics.c for details.  */
+#define CP_ACC_CLAUSE_INFO(NODE)                   TREE_TYPE (NODE)
+
 /* Nonzero if this transaction expression's body contains statements.  */
 #define TRANSACTION_EXPR_IS_STMT(NODE) \
    TREE_LANG_FLAG_0 (TRANSACTION_EXPR_CHECK (NODE))
@@ -5167,7 +5172,8 @@ extern tree duplicate_decls			(tree, tree, bool);
 extern tree declare_local_label			(tree);
 extern tree define_label			(location_t, tree);
 extern void check_goto				(tree);
-extern bool check_omp_return			(void);
+extern bool check_omp_return                    (void);
+extern bool check_acc_return                    (void);
 extern tree make_typename_type			(tree, tree, enum tag_types, tsubst_flags_t);
 extern tree make_unbound_class_template		(tree, tree, tree, tsubst_flags_t);
 extern tree build_library_fn_ptr		(const char *, tree, int);
@@ -5774,6 +5780,16 @@ extern tree finish_qualified_id_expr		(tree, tree, bool, bool,
 extern void simplify_aggr_init_expr		(tree *);
 extern void finalize_nrv			(tree *, tree, tree);
 extern void note_decl_for_pch			(tree);
+
+extern tree begin_acc_structured_block          (void);
+extern tree finish_acc_structured_block         (tree);
+extern tree begin_acc_parallel                  (void);
+extern tree finish_acc_parallel                 (tree, tree);
+extern tree begin_acc_kernels                   (void);
+extern tree finish_acc_kernels                  (tree, tree);
+extern tree finish_acc_clauses                  (tree);
+
+
 extern tree finish_omp_clauses			(tree);
 extern void finish_omp_threadprivate		(tree);
 extern tree begin_omp_structured_block		(void);
diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index 80ceca138d8..78fc3e99866 100644
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -196,6 +196,8 @@ struct GTY((chain_next ("%h.next"))) named_label_use_entry {
      the goto appeared.  This means that the branch from the label will
      illegally exit an OpenMP scope.  */
   bool in_omp_scope;
+
+  bool in_acc_scope;
 };
 
 /* A list of all LABEL_DECLs in the function that have names.  Here so
@@ -227,6 +229,7 @@ struct GTY(()) named_label_entry {
   bool in_try_scope;
   bool in_catch_scope;
   bool in_omp_scope;
+  bool in_acc_scope;
 };
 
 #define named_labels cp_function_chain->x_named_labels
@@ -494,9 +497,12 @@ poplevel_named_label_1 (void **slot, void *data)
 	case sk_catch:
 	  ent->in_catch_scope = true;
 	  break;
-	case sk_omp:
-	  ent->in_omp_scope = true;
-	  break;
+        case sk_omp:
+          ent->in_omp_scope = true;
+          break;
+        case sk_acc:
+          ent->in_acc_scope = true;
+          break;
 	default:
 	  break;
 	}
@@ -510,8 +516,10 @@ poplevel_named_label_1 (void **slot, void *data)
 	  {
 	    use->binding_level = obl;
 	    use->names_in_scope = obl->names;
-	    if (bl->kind == sk_omp)
-	      use->in_omp_scope = true;
+            if (bl->kind == sk_omp)
+              use->in_omp_scope = true;
+            if (bl->kind == sk_acc)
+              use->in_acc_scope = true;
 	  }
     }
 
@@ -2768,11 +2776,12 @@ identify_goto (tree decl, const location_t *locus)
    true if all is well.  */
 
 static bool
-check_previous_goto_1 (tree decl, cp_binding_level* level, tree names,
-		       bool exited_omp, const location_t *locus)
+check_previous_goto_1 (tree decl, cp_binding_level* level,
+                       tree names, bool exited_omp,
+                       bool exited_acc, const location_t *locus)
 {
   cp_binding_level *b;
-  bool identified = false, saw_eh = false, saw_omp = false;
+  bool identified = false, saw_eh = false, saw_omp = false, saw_acc = false;
 
   if (exited_omp)
     {
@@ -2781,6 +2790,13 @@ check_previous_goto_1 (tree decl, cp_binding_level* level, tree names,
       identified = saw_omp = true;
     }
 
+  if (exited_acc)
+  {
+    identify_goto (decl, locus);
+    error ("  exits OpenACC structured block");
+    identified = saw_acc = true;
+  }
+
   for (b = current_binding_level; b ; b = b->level_chain)
     {
       tree new_decls, old_decls = (b == level ? names : NULL_TREE);
@@ -2821,15 +2837,25 @@ check_previous_goto_1 (tree decl, cp_binding_level* level, tree names,
 	  saw_eh = true;
 	}
       if (b->kind == sk_omp && !saw_omp)
-	{
-	  if (!identified)
-	    {
-	      identify_goto (decl, locus);
-	      identified = true;
-	    }
-	  error ("  enters OpenMP structured block");
-	  saw_omp = true;
-	}
+        {
+          if (!identified)
+            {
+              identify_goto (decl, locus);
+              identified = true;
+            }
+          error ("  enters OpenMP structured block");
+          saw_omp = true;
+        }
+      if (b->kind == sk_acc && !saw_acc)
+      {
+        if (!identified)
+          {
+            identify_goto (decl, locus);
+            identified = true;
+          }
+        error ("  enters OpenACC structured block");
+        saw_acc = true;
+      }
     }
 
   return !identified;
@@ -2839,14 +2865,17 @@ static void
 check_previous_goto (tree decl, struct named_label_use_entry *use)
 {
   check_previous_goto_1 (decl, use->binding_level,
-			 use->names_in_scope, use->in_omp_scope,
+			 use->names_in_scope,
+			 use->in_omp_scope,
+			 use->in_acc_scope,
 			 &use->o_goto_locus);
 }
 
 static bool
 check_switch_goto (cp_binding_level* level)
 {
-  return check_previous_goto_1 (NULL_TREE, level, level->names, false, NULL);
+  return check_previous_goto_1 (NULL_TREE, level, level->names,
+                                false, false, NULL);
 }
 
 /* Check that a new jump to a label DECL is OK.  Called by
@@ -2890,14 +2919,18 @@ check_goto (tree decl)
       new_use->names_in_scope = current_binding_level->names;
       new_use->o_goto_locus = input_location;
       new_use->in_omp_scope = false;
+      new_use->in_acc_scope = false;
 
       new_use->next = ent->uses;
       ent->uses = new_use;
       return;
     }
 
-  if (ent->in_try_scope || ent->in_catch_scope
-      || ent->in_omp_scope || !vec_safe_is_empty (ent->bad_decls))
+  if (ent->in_try_scope
+      || ent->in_catch_scope
+      || ent->in_omp_scope
+      || ent->in_acc_scope
+      || !vec_safe_is_empty (ent->bad_decls))
     {
       permerror (input_location, "jump to label %q+D", decl);
       permerror (input_location, "  from here");
@@ -2948,6 +2981,29 @@ check_goto (tree decl)
 	    }
 	}
     }
+
+  if (ent->in_acc_scope)
+    error ("  enters OpenACC structured block");
+  else if (flag_openacc)
+    {
+      cp_binding_level *b;
+      for (b = current_binding_level; b ; b = b->level_chain)
+        {
+          if (b == ent->binding_level)
+            break;
+          if (b->kind == sk_acc)
+            {
+              if (!identified)
+                {
+                  permerror (input_location, "jump to label %q+D", decl);
+                  permerror (input_location, "  from here");
+                  identified = true;
+                }
+              error ("  exits OpenACC structured block");
+              break;
+            }
+        }
+    }
 }
 
 /* Check that a return is ok wrt OpenMP structured blocks.
@@ -2968,6 +3024,24 @@ check_omp_return (void)
   return true;
 }
 
+/* Check that a return is ok wrt OpenACC structured blocks.
+ * Called by finish_return_stmt.  Returns true if all is well.
+ */
+bool
+check_acc_return (void)
+{
+  cp_binding_level *b;
+  for (b = current_binding_level; b ; b = b->level_chain)
+    if (b->kind == sk_acc)
+      {
+        error ("invalid exit from OpenACC structured block");
+        return false;
+      }
+    else if (b->kind == sk_function_parms)
+      break;
+  return true;
+}
+
 /* Define a label, specifying the location in the source file.
    Return the LABEL_DECL node for the label.  */
 
diff --git a/gcc/cp/name-lookup.c b/gcc/cp/name-lookup.c
index 025a03cd9fa..4844ff5c798 100644
--- a/gcc/cp/name-lookup.c
+++ b/gcc/cp/name-lookup.c
@@ -1547,6 +1547,7 @@ begin_scope (scope_kind kind, tree entity)
     case sk_scoped_enum:
     case sk_function_parms:
     case sk_omp:
+    case sk_acc:
       scope->keep = keep_next_level_flag;
       break;
 
@@ -1711,7 +1712,7 @@ bool
 local_bindings_p (void)
 {
   cp_binding_level *b = innermost_nonclass_level ();
-  return b->kind < sk_function_parms || b->kind == sk_omp;
+  return b->kind < sk_function_parms || b->kind == sk_omp || b->kind == sk_acc;
 }
 
 /* True if the current level needs to have a BLOCK made.  */
diff --git a/gcc/cp/name-lookup.h b/gcc/cp/name-lookup.h
index 57641a19902..f30a2c043b6 100644
--- a/gcc/cp/name-lookup.h
+++ b/gcc/cp/name-lookup.h
@@ -120,7 +120,8 @@ typedef enum scope_kind {
 			specialization.  Since, by definition, an
 			explicit specialization is introduced by
 			"template <>", this scope is always empty.  */
-  sk_omp	     /* An OpenMP structured block.  */
+  sk_omp,            /* An OpenMP structured block.  */
+  sk_acc             /* An OpenACC structured block.  */
 } scope_kind;
 
 /* The scope where the class/struct/union/enum tag applies.  */
diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index 2cd60f0db9d..15bce4a55f1 100644
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -28387,7 +28387,752 @@ cp_parser_omp_construct (cp_parser *parser, cp_token *pragma_tok)
   if (stmt)
     SET_EXPR_LOCATION (stmt, pragma_tok->location);
 }
-
+
+
+/********************** OpenACC parsing routines ******************************/
+/******************************************************************************/
+
+static tree
+cp_parser_acc_var_list_no_open (cp_parser *parser,
+                                enum acc_clause_code kind,
+                                tree list)
+{
+  cp_token *token;
+  
+  while (1)
+  {
+    tree name, decl;
+
+    token = cp_lexer_peek_token (parser->lexer);
+    name = cp_parser_id_expression (parser,
+                                    /*template_p=*/false,
+                                    /*_dependency_p=*/true,
+                                    /*template_p=*/NULL,
+                                    /*declarator_p=*/false,
+                                    /*optional_p=*/false);
+
+    if (name == error_mark_node)
+    {
+      goto skip_comma;
+    }
+
+    decl = cp_parser_lookup_name_simple (parser, name, token->location);
+    
+    if (decl == error_mark_node)
+    {
+      cp_parser_name_lookup_error (parser, name, decl,
+                                   NLE_NULL, token->location);
+    }
+    else if (kind != 0)
+    {
+      tree u = build_acc_clause (token->location, kind);
+      ACC_CLAUSE_DECL (u) = decl;
+      ACC_CLAUSE_CHAIN (u) = list;
+      list = u;
+    }
+    else
+    {
+      list = tree_cons (decl, NULL_TREE, list);
+    }
+
+  get_comma:
+    if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
+    {
+      break;
+    }
+      
+    cp_lexer_consume_token (parser->lexer);
+  }
+
+  if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
+  {
+    int ending;
+
+    /* Try to resync to an unnested comma.  Copied from
+       cp_parser_parenthesized_expression_list.  */
+  skip_comma:
+    ending = cp_parser_skip_to_closing_parenthesis (parser,
+                                                    /*recovering=*/true,
+                                                    /*or_comma=*/true,
+                                                    /*consume_paren=*/true);
+  if (ending < 0)
+    {
+      goto get_comma;
+    }
+  }
+
+  return list;
+}
+
+/* Similarly, but expect leading and trailing parenthesis.  This is a very
+   common case for clauses.  */
+static tree
+cp_parser_acc_var_list (cp_parser *parser,
+                        enum acc_clause_code kind,
+                        tree list)
+{
+  if (cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
+  {
+    return cp_parser_acc_var_list_no_open (parser, kind, list);
+  }
+  
+  return list;
+}
+
+/* Returns name of the next clause.
+   If the clause is not recognized PRAGMA_ACC_CLAUSE_NONE is returned and
+   the token is not consumed.  Otherwise appropriate pragma_acc_clause is
+   returned and the token is consumed.  */
+static pragma_acc_clause
+cp_parser_acc_clause_name (cp_parser *parser)
+{
+  pragma_acc_clause result = PRAGMA_ACC_CLAUSE_NONE;
+
+  if (cp_lexer_next_token_is_keyword (parser->lexer, RID_IF))
+  {
+    result = PRAGMA_ACC_CLAUSE_IF;
+  }
+  else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
+  {
+    tree id = cp_lexer_peek_token (parser->lexer)->u.value;
+    const char *p = IDENTIFIER_POINTER (id);
+    result = pragma_acc_clause_get_name(p, result);
+  }
+
+  if (result != PRAGMA_ACC_CLAUSE_NONE)
+  {
+    cp_lexer_consume_token (parser->lexer);
+  }
+  
+  return result;
+}
+
+/* Validate that a ACC clause of the given type does not already exist.  */
+static void
+cp_parser_acc_clause_check_no_duplicate (tree clauses,
+                                         enum acc_clause_code code,
+                                         const char *name,
+                                         location_t location)
+{
+  tree c;
+
+  for (c = clauses; c ; c = ACC_CLAUSE_CHAIN (c))
+  {
+    if (ACC_CLAUSE_CODE (c) == code)
+    {
+      error_at (location, "too many %qs clauses", name);
+      break;
+    }
+  }
+}
+
+/* Check if a given clause has parenthesis */
+static tree
+cp_parser_acc_check_parenthesis(tree t, cp_parser* parser)
+{
+  if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
+  {
+    return t;
+  }
+
+  t = cp_parser_expression (parser, false, NULL);
+
+  if (t == error_mark_node ||
+      !cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
+  {
+    cp_parser_skip_to_closing_parenthesis (parser,
+                                           /*recovering=*/true,
+                                           /*or_comma=*/false,
+                                           /*consume_paren=*/true);
+  }
+
+  return t;
+}
+
+/* OpenACC 1.0:
+   seq */
+static tree
+cp_parser_acc_clause_seq (cp_parser* /*parser*/,
+                          tree list,
+                          location_t location)
+{
+  tree c;
+
+  cp_parser_acc_clause_check_no_duplicate (list,
+                                           ACC_CLAUSE_SEQ,
+                                           "seq",
+                                           location);
+
+  c = build_acc_clause (location, ACC_CLAUSE_SEQ);
+  ACC_CLAUSE_CHAIN (c) = list;
+  return c;
+}
+
+/* OpenACC 1.0:
+   independent */
+static tree
+cp_parser_acc_clause_independent (cp_parser* /*parser*/,
+                                  tree list,
+                                  location_t location)
+{
+  tree c;
+
+  cp_parser_acc_clause_check_no_duplicate (list,
+                                           ACC_CLAUSE_INDEPENDENT,
+                                           "independent",
+                                           location);
+
+  c = build_acc_clause (location, ACC_CLAUSE_INDEPENDENT);
+  ACC_CLAUSE_CHAIN (c) = list;
+  return c;
+}
+
+/* OpenACC 1.0:
+   num_workers ( expression ) */
+static tree
+cp_parser_acc_clause_num_workers (cp_parser *parser,
+                                  tree list,
+                                  location_t location)
+{
+  tree t = NULL_TREE, c;
+
+  t = cp_parser_acc_check_parenthesis(t, parser);
+  cp_parser_acc_clause_check_no_duplicate (list,
+                                           ACC_CLAUSE_NUM_WORKERS,
+                                           "num_workers",
+                                           location);
+
+  c = build_acc_clause (location, ACC_CLAUSE_NUM_WORKERS);
+  ACC_CLAUSE_NUM_WORKERS_EXPR (c) = t;
+  ACC_CLAUSE_CHAIN (c) = list;
+
+  return c;
+}
+
+/* OpenACC 1.0:
+   num_gangs ( expression ) */
+static tree
+cp_parser_acc_clause_num_gangs (cp_parser *parser,
+                                tree list,
+                                location_t location)
+{
+  tree t = NULL_TREE, c;
+
+  t = cp_parser_acc_check_parenthesis(t, parser);
+  cp_parser_acc_clause_check_no_duplicate (list, ACC_CLAUSE_NUM_GANGS,
+                                           "num_gangs", location);
+
+  c = build_acc_clause (location, ACC_CLAUSE_NUM_GANGS);
+  ACC_CLAUSE_NUM_GANGS_EXPR (c) = t;
+  ACC_CLAUSE_CHAIN (c) = list;
+
+  return c;
+}
+
+/* OpenACC 1.0:
+   vector_length ( expression ) */
+static tree
+cp_parser_acc_clause_vector_length (cp_parser *parser,
+                                    tree list,
+                                    location_t location)
+{
+  tree t = NULL_TREE, c;
+
+  t = cp_parser_acc_check_parenthesis(t, parser);
+  cp_parser_acc_clause_check_no_duplicate (list,
+                                           ACC_CLAUSE_VECTOR_LENGTH,
+                                           "vector_length",
+                                           location);
+
+  c = build_acc_clause (location, ACC_CLAUSE_VECTOR_LENGTH);
+  ACC_CLAUSE_VECTOR_LENGTH_EXPR (c) = t;
+  ACC_CLAUSE_CHAIN (c) = list;
+
+  return c;
+}
+
+/* OpenACC 1.0:
+   collapse ( constant-expression ) */
+static tree
+cp_parser_acc_clause_collapse (cp_parser *parser, tree list, location_t location)
+{
+  tree c, num;
+  location_t loc;
+  HOST_WIDE_INT n;
+
+  loc = cp_lexer_peek_token (parser->lexer)->location;
+  if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
+    return list;
+
+  num = cp_parser_constant_expression (parser, false, NULL);
+
+  if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
+  {
+    cp_parser_skip_to_closing_parenthesis (parser,
+                                           /*recovering=*/true,
+                                           /*or_comma=*/false,
+                                           /*consume_paren=*/true);
+  }
+
+  if (num == error_mark_node)
+  {
+    return list;
+  }
+
+  num = fold_non_dependent_expr (num);
+  if (!INTEGRAL_TYPE_P (TREE_TYPE (num))
+      || !host_integerp (num, 0)
+      || (n = tree_low_cst (num, 0)) <= 0
+      || (int) n != n)
+  {
+    error_at (loc,
+              "collapse argument needs positive constant integer expression");
+    return list;
+  }
+
+  cp_parser_acc_clause_check_no_duplicate (list, ACC_CLAUSE_COLLAPSE,
+                                           "collapse", location);
+  c = build_acc_clause (loc, ACC_CLAUSE_COLLAPSE);
+  ACC_CLAUSE_CHAIN (c) = list;
+  ACC_CLAUSE_COLLAPSE_EXPR (c) = num;
+
+  return c;
+}
+
+/* OpenACC 1.0:
+   if ( expression ) */
+static tree
+cp_parser_acc_clause_if (cp_parser *parser, tree list, location_t location)
+{
+  tree t = NULL_TREE, c;
+
+  t = cp_parser_acc_check_parenthesis(t, parser);
+  cp_parser_acc_clause_check_no_duplicate (list, ACC_CLAUSE_IF,
+                                           "if", location);
+
+  c = build_acc_clause (location, ACC_CLAUSE_IF);
+  ACC_CLAUSE_IF_EXPR (c) = t;
+  ACC_CLAUSE_CHAIN (c) = list;
+
+  return c;
+}
+
+/* OpenACC 1.0
+ * FIXME Too identical to OMP - mb merge?
+*/
+
+static tree
+cp_parser_acc_clause_reduction (cp_parser *parser, tree list)
+{
+  enum tree_code code;
+  tree nlist, c;
+
+  if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
+    return list;
+
+  switch (cp_lexer_peek_token (parser->lexer)->type)
+    {
+    case CPP_PLUS:
+      code = PLUS_EXPR;
+      break;
+    case CPP_MULT:
+      code = MULT_EXPR;
+      break;
+    case CPP_MINUS:
+      code = MINUS_EXPR;
+      break;
+    case CPP_AND:
+      code = BIT_AND_EXPR;
+      break;
+    case CPP_XOR:
+      code = BIT_XOR_EXPR;
+      break;
+    case CPP_OR:
+      code = BIT_IOR_EXPR;
+      break;
+    case CPP_AND_AND:
+      code = TRUTH_ANDIF_EXPR;
+      break;
+    case CPP_OR_OR:
+      code = TRUTH_ORIF_EXPR;
+      break;
+    case CPP_NAME:
+      {
+        tree id = cp_lexer_peek_token (parser->lexer)->u.value;
+        const char *p = IDENTIFIER_POINTER (id);
+
+        if (strcmp (p, "min") == 0)
+          {
+            code = MIN_EXPR;
+            break;
+          }
+        if (strcmp (p, "max") == 0)
+          {
+            code = MAX_EXPR;
+            break;
+          }
+      }
+      /* FALLTHROUGH */
+    default:
+      cp_parser_error (parser, "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, "
+                               "%<|%>, %<&&%>, %<||%>, %<min%> or %<max%>");
+    resync_fail:
+      cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
+                                             /*or_comma=*/false,
+                                             /*consume_paren=*/true);
+      return list;
+    }
+  cp_lexer_consume_token (parser->lexer);
+
+  if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
+    goto resync_fail;
+
+  nlist = cp_parser_acc_var_list_no_open (parser, ACC_CLAUSE_REDUCTION, list);
+  for (c = nlist; c != list; c = ACC_CLAUSE_CHAIN (c))
+    ACC_CLAUSE_REDUCTION_CODE (c) = code;
+
+  return nlist;
+}
+
+
+/* Parse all OpenACC clauses. */
+static tree
+cp_parser_acc_all_clauses (cp_parser *parser,
+                           unsigned int mask,
+                           const char *where,
+                           cp_token *pragma_tok)
+{
+  tree clauses = NULL;
+  bool first = true;
+  cp_token *token = NULL;
+
+  while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
+  {
+    pragma_acc_clause c_kind;
+    const char *c_name;
+    tree prev = clauses;
+
+    /* For what do we need it? Why comma? */ 
+    if (!first && cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
+    {
+      cp_lexer_consume_token (parser->lexer);
+    }
+    
+    token = cp_lexer_peek_token (parser->lexer);    
+    c_kind = cp_parser_acc_clause_name (parser);
+    first = false;
+
+    switch (c_kind)
+    {
+    case PRAGMA_ACC_CLAUSE_SEQ:
+      clauses = cp_parser_acc_clause_seq (parser,
+                                          clauses,
+                                          token->location);
+      c_name = "seq";
+      break;
+    case PRAGMA_ACC_CLAUSE_INDEPENDENT:
+      clauses = cp_parser_acc_clause_independent (parser,
+                                                  clauses,
+                                                  token->location);
+      c_name = "independent";
+      break;
+    case PRAGMA_ACC_CLAUSE_NUM_GANGS:
+      clauses = cp_parser_acc_clause_num_gangs (parser,
+                                                clauses,
+                                                token->location);
+      c_name = "num_gangs";
+      break;
+    case PRAGMA_ACC_CLAUSE_NUM_WORKERS:
+      clauses = cp_parser_acc_clause_num_workers (parser,
+                                                  clauses,
+                                                  token->location);
+      c_name = "num_workers";
+      break;
+    case PRAGMA_ACC_CLAUSE_VECTOR_LENGTH:
+      clauses = cp_parser_acc_clause_vector_length (parser,
+                                                    clauses,
+                                                    token->location);
+      c_name = "vector_length";
+      break;
+    case PRAGMA_ACC_CLAUSE_IF:
+      clauses = cp_parser_acc_clause_if (parser,
+                                         clauses,
+                                         token->location);
+      c_name = "if";
+      break;     
+        
+    case PRAGMA_ACC_CLAUSE_COPY:
+      clauses = cp_parser_acc_var_list (parser,
+                                        ACC_CLAUSE_COPY,
+                                        clauses);
+      c_name = "copy";
+      break;
+    case PRAGMA_ACC_CLAUSE_COPYIN:
+      clauses = cp_parser_acc_var_list (parser,
+                                        ACC_CLAUSE_COPYIN,
+                                        clauses);
+      c_name = "copyin";
+      break;
+    case PRAGMA_ACC_CLAUSE_COPYOUT:
+      clauses = cp_parser_acc_var_list (parser,
+                                        ACC_CLAUSE_COPYOUT,
+                                        clauses);
+      c_name = "copyout";
+      break;
+    case PRAGMA_ACC_CLAUSE_PRESENT_OR_COPY:
+      clauses = cp_parser_acc_var_list (parser,
+                                        ACC_CLAUSE_PRESENT_OR_COPY,
+                                        clauses);
+      c_name = "present_or_copy";
+      break;
+    case PRAGMA_ACC_CLAUSE_PRESENT_OR_COPYIN:
+      clauses = cp_parser_acc_var_list (parser,
+                                        ACC_CLAUSE_PRESENT_OR_COPYIN,
+                                        clauses);
+      c_name = "present_or_copyin";
+      break;
+    case PRAGMA_ACC_CLAUSE_PRESENT_OR_COPYOUT:
+      clauses = cp_parser_acc_var_list (parser,
+                                        ACC_CLAUSE_PRESENT_OR_COPYOUT,
+                                        clauses);
+      c_name = "present_or_copyout";
+      break;
+    case PRAGMA_ACC_CLAUSE_PRIVATE:
+      clauses = cp_parser_acc_var_list (parser,
+                                        ACC_CLAUSE_PRIVATE,
+                                        clauses);
+      c_name = "private";
+      break;
+    case PRAGMA_ACC_CLAUSE_FIRSTPRIVATE:
+      clauses = cp_parser_acc_var_list (parser,
+                                        ACC_CLAUSE_FIRSTPRIVATE,
+                                        clauses);
+      c_name = "firstprivate";
+      break;
+    case PRAGMA_ACC_CLAUSE_PRESENT:
+      clauses = cp_parser_acc_var_list (parser,
+                                        ACC_CLAUSE_PRESENT,
+                                        clauses);
+      c_name = "present";
+      break;
+    case PRAGMA_ACC_CLAUSE_CREATE:
+      clauses = cp_parser_acc_var_list (parser,
+                                        ACC_CLAUSE_CREATE,
+                                        clauses);
+      c_name = "create";
+      break;
+    case PRAGMA_ACC_CLAUSE_PRESENT_OR_CREATE:
+      clauses = cp_parser_acc_var_list (parser,
+                                        ACC_CLAUSE_PRESENT_OR_CREATE,
+                                        clauses);
+      c_name = "present_or_create";
+      break;
+    case PRAGMA_ACC_CLAUSE_COLLAPSE:
+      clauses = cp_parser_acc_clause_collapse (parser, 
+                                        clauses,
+                                        token->location);
+      c_name = "collapse";
+      break;
+    case PRAGMA_ACC_CLAUSE_REDUCTION:
+      clauses = cp_parser_acc_clause_reduction (parser, clauses);
+      c_name = "reduction";
+      break;
+
+    default:
+      cp_parser_error (parser, "expected %<#pragma acc%> clause");
+      goto saw_error;
+    }
+  
+    if (((mask >> c_kind) & 1) == 0)
+    {
+      /* Remove the invalid clause(s) from the list to avoid
+         confusing the rest of the compiler.  */
+      clauses = prev;
+      error_at (token->location, "%qs is not valid for %qs", c_name, where);
+    }
+  }
+
+  saw_error:
+  cp_parser_skip_to_pragma_eol (parser, pragma_tok);
+
+  return finish_acc_clauses (clauses); // validate and remove the broken ones
+}
+
+static unsigned
+cp_parser_begin_acc_structured_block (cp_parser *parser)
+{
+  unsigned save = parser->in_statement;
+
+  if (parser->in_statement)
+    parser->in_statement = IN_ACC_BLOCK;
+
+  return save;
+}
+
+static void
+cp_parser_end_acc_structured_block (cp_parser *parser, unsigned save)
+{
+  parser->in_statement = save;
+}
+
+static tree
+cp_parser_acc_structured_block (cp_parser *parser)
+{
+  tree stmt = begin_acc_structured_block ();
+  unsigned int save = cp_parser_begin_acc_structured_block (parser);
+
+  cp_parser_statement (parser, NULL_TREE, false, NULL);
+
+  cp_parser_end_acc_structured_block (parser, save);
+  return finish_acc_structured_block (stmt);
+}
+
+/* OpenACC 1.0:
+   #pragma parallel acc-parallel-clause new-line */
+static tree
+cp_parser_acc_parallel (cp_parser *parser, cp_token *pragma_tok)
+{
+  enum pragma_kind p_kind = PRAGMA_ACC_PARALLEL;
+  const char *p_name = "#pragma acc parallel";
+  tree stmt, clauses = NULL_TREE, block;
+  unsigned int mask = ACC_PARALLEL_CLAUSE_MASK;
+  unsigned int save;
+  location_t loc = cp_lexer_peek_token (parser->lexer)->location;
+
+  if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
+  {
+    tree id = cp_lexer_peek_token (parser->lexer)->u.value;
+    const char *p = IDENTIFIER_POINTER (id);
+
+    if (strcmp (p, "loop") == 0)
+    {
+      cp_lexer_consume_token (parser->lexer);
+      p_kind = PRAGMA_ACC_PARALLEL_LOOP;
+      p_name = "#pragma acc parallel loop";
+      mask |= ACC_LOOP_CLAUSE_MASK;
+    }
+  }
+
+  clauses = cp_parser_acc_all_clauses (parser, mask, p_name, pragma_tok);
+  block = begin_acc_parallel ();
+  save = cp_parser_begin_acc_structured_block (parser);
+
+  //cp_parser_statement (parser, NULL_TREE, false, NULL);
+
+  cp_parser_end_acc_structured_block (parser, save);
+  stmt = finish_acc_parallel (clauses, block);
+
+  return stmt;
+}
+
+/* OpenACC 1.0:
+   # pragma kernels acc-kernels-clause new-line */
+static tree
+cp_parser_acc_kernels (cp_parser *parser, cp_token *pragma_tok)
+{
+  enum pragma_kind p_kind = PRAGMA_ACC_KERNELS;
+  const char *p_name = "#pragma acc kernels";
+  tree stmt, clauses, par_clause, block;
+  unsigned int mask = ACC_KERNELS_CLAUSE_MASK;
+  unsigned int save;
+  location_t loc = cp_lexer_peek_token (parser->lexer)->location;
+
+  if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
+  {
+    tree id = cp_lexer_peek_token (parser->lexer)->u.value;
+    const char *p = IDENTIFIER_POINTER (id);
+
+    if (strcmp (p, "loop") == 0)
+    {
+      cp_lexer_consume_token (parser->lexer);
+      p_kind = PRAGMA_ACC_KERNELS_LOOP;
+      p_name = "#pragma acc kernels loop";
+      mask |= ACC_LOOP_CLAUSE_MASK;
+    }
+  }
+
+  //clauses = cp_parser_acc_all_clauses (parser, mask, p_name, pragma_tok);
+  block = begin_acc_kernels ();
+  save = cp_parser_begin_acc_structured_block (parser);
+
+  //cp_parser_statement (parser, NULL_TREE, false, NULL);
+
+  cp_parser_end_acc_structured_block (parser, save);
+  stmt = finish_acc_kernels (clauses, block);
+
+  return stmt;
+}
+
+/* OpenACC 1.0:
+   # pragma data */
+static tree
+cp_parser_acc_data (cp_parser *parser, cp_token *pragma_tok)
+{
+  tree stmt = make_node (ACC_DATA);
+  TREE_TYPE (stmt) = void_type_node;
+/*
+  ACC_DATA_CLAUSES (stmt) = cp_parser_acc_all_clauses (parser,
+                                                       ACC_DATA_CLAUSE_MASK,
+                                                       "#pragma acc data",
+                                                       pragma_tok);
+*/
+
+  cp_parser_skip_to_pragma_eol (parser, pragma_tok);
+  ACC_DATA_BODY (stmt) = cp_parser_acc_structured_block (parser);
+
+  return add_stmt (stmt);
+}
+
+/* Main entry point to OpenACC statement pragmas. */
+static void
+cp_parser_acc_construct (cp_parser *parser, cp_token *pragma_tok)
+{
+  tree stmt;
+
+  switch (pragma_tok->pragma_kind)
+  {
+  case PRAGMA_ACC_PARALLEL:
+    stmt = cp_parser_acc_parallel (parser, pragma_tok);
+    break;
+  case PRAGMA_ACC_KERNELS:
+    stmt = cp_parser_acc_kernels (parser, pragma_tok);
+    break;
+  case PRAGMA_ACC_DATA:
+  stmt = cp_parser_acc_data (parser, pragma_tok);
+    break;
+  case PRAGMA_ACC_CACHE:
+  //stmt = cp_parser_acc_cache (parser, pragma_tok);
+    break;
+  case PRAGMA_ACC_WAIT:
+  //stmt = cp_parser_acc_wait (parser, pragma_tok);
+    break;
+  case PRAGMA_ACC_HOST_DATA:
+  //stmt = cp_parser_acc_host_data (parser, pragma_tok);
+    break;
+  case PRAGMA_ACC_LOOP:
+  //stmt = cp_parser_acc_loop (parser, pragma_tok);
+    break;
+  case PRAGMA_ACC_DECLARE:
+  //stmt = cp_parser_acc_declare (parser, pragma_tok);
+    break;
+  case PRAGMA_ACC_UPDATE:
+  //stmt = cp_parser_acc_update (parser, pragma_tok);
+    break;
+
+    default:
+      gcc_unreachable ();
+  }
+
+  if (stmt)
+  {
+    SET_EXPR_LOCATION (stmt, pragma_tok->location);
+  }
+}
+
+/********************** End of OpenACC parsing routines ***********************/
+/******************************************************************************/
+
+
 /* Transactional Memory parsing routines.  */
 
 /* Parse a transaction attribute.
@@ -28829,6 +29574,22 @@ cp_parser_pragma (cp_parser *parser, enum pragma_context context)
 		"%<#pragma omp sections%> construct");
       break;
 
+    case PRAGMA_ACC_CACHE:
+    case PRAGMA_ACC_DATA:
+    case PRAGMA_ACC_DECLARE:
+    case PRAGMA_ACC_HOST_DATA:
+    case PRAGMA_ACC_KERNELS:
+    case PRAGMA_ACC_LOOP:
+    case PRAGMA_ACC_PARALLEL:
+    case PRAGMA_ACC_UPDATE:
+    case PRAGMA_ACC_WAIT:
+      if (context == pragma_external)
+      {
+        goto bad_stmt;
+      }
+      cp_parser_acc_construct (parser, pragma_tok);
+      break;
+
     default:
       gcc_assert (id >= PRAGMA_FIRST_EXTERNAL);
       c_invoke_pragma_handler (id);
diff --git a/gcc/cp/parser.h b/gcc/cp/parser.h
index ffdddaf4a08..5a9b4fa9757 100644
--- a/gcc/cp/parser.h
+++ b/gcc/cp/parser.h
@@ -292,6 +292,8 @@ typedef struct GTY(()) cp_parser {
 #define IN_OMP_BLOCK		4
 #define IN_OMP_FOR		8
 #define IN_IF_STMT             16
+#define IN_ACC_BLOCK           32
+#define IN_ACC_LOOP            64
   unsigned char in_statement;
 
   /* TRUE if we are presently parsing the body of a switch statement.
diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index 0299b690fb1..0007ba35f6b 100644
--- a/gcc/cp/semantics.c
+++ b/gcc/cp/semantics.c
@@ -789,6 +789,8 @@ finish_return_stmt (tree expr)
 
   if (flag_openmp && !check_omp_return ())
     return error_mark_node;
+  if (flag_openacc && !check_acc_return ())
+    return error_mark_node;
   if (!processing_template_decl)
     {
       if (warn_sequence_point)
@@ -4041,7 +4043,448 @@ finalize_nrv (tree *tp, tree var, tree result)
   cp_walk_tree (tp, finalize_nrv_r, &data, 0);
   data.visited.dispose ();
 }
-
+
+/********************** OpenACC parsing routines ******************************/
+/******************************************************************************/
+tree
+begin_acc_structured_block (void)
+{
+  return do_pushlevel (sk_acc);
+}
+
+tree
+finish_acc_structured_block (tree block)
+{
+  return do_poplevel (block);
+}
+
+tree
+begin_acc_parallel (void)
+{
+  keep_next_level (true);
+  return begin_acc_structured_block ();
+}
+
+tree
+finish_acc_parallel (tree clauses, tree body)
+{
+  tree stmt;
+
+  body = finish_acc_structured_block (body);
+
+  stmt = make_node (ACC_PARALLEL);
+  TREE_TYPE (stmt) = void_type_node;
+  ACC_PARALLEL_CLAUSES (stmt) = clauses;
+  ACC_PARALLEL_BODY (stmt) = body;
+
+  return add_stmt (stmt);
+}
+
+tree
+begin_acc_kernels (void)
+{
+  keep_next_level (true);
+  return begin_acc_structured_block ();
+}
+
+tree
+finish_acc_kernels (tree clauses, tree body)
+{
+  tree stmt;
+
+  body = finish_acc_structured_block (body);
+
+  stmt = make_node (ACC_KERNELS);
+  TREE_TYPE (stmt) = void_type_node;
+  ACC_KERNELS_CLAUSES (stmt) = clauses;
+  ACC_KERNELS_BODY (stmt) = body;
+
+  return add_stmt (stmt);
+}
+
+/* Create CP_ACC_CLAUSE_INFO for clause C.
+ * Returns true if it is invalid.  */
+
+bool
+cxx_acc_create_clause_info (tree c,
+                            tree type,
+                            bool need_default_ctor,
+                            bool need_copy_ctor,
+                            bool need_copy_assignment)
+{
+  int save_errorcount = errorcount;
+  tree info, t;
+
+  /* Always allocate 3 elements for simplicity.  These are the
+     function decls for the ctor, dtor, and assignment op.
+     This layout is known to the three lang hooks,
+     cxx_acc_clause_default_init, cxx_acc_clause_copy_init,
+     and cxx_acc_clause_assign_op.  */
+  info = make_tree_vec (3);
+  CP_ACC_CLAUSE_INFO (c) = info;
+
+  if (need_default_ctor || need_copy_ctor)
+    {
+      if (need_default_ctor)
+        t = get_default_ctor (type);
+      else
+        t = get_copy_ctor (type, tf_warning_or_error);
+
+      if (t && !trivial_fn_p (t))
+        TREE_VEC_ELT (info, 0) = t;
+    }
+
+  if ((need_default_ctor || need_copy_ctor)
+      && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
+    TREE_VEC_ELT (info, 1) = get_dtor (type, tf_warning_or_error);
+
+  if (need_copy_assignment)
+    {
+      t = get_copy_assign (type);
+
+      if (t && !trivial_fn_p (t))
+        TREE_VEC_ELT (info, 2) = t;
+    }
+
+  return errorcount != save_errorcount;
+}
+
+/* Validata all CLAUSES
+   Remove any invalid.  */
+tree
+finish_acc_clauses (tree clauses)
+{
+  bitmap_head generic_head, firstprivate_head;
+  tree c, t, *pc = &clauses;
+  const char *name;
+
+  bitmap_obstack_initialize (NULL);
+  bitmap_initialize (&generic_head, &bitmap_default_obstack);
+  bitmap_initialize (&firstprivate_head, &bitmap_default_obstack);
+
+  for (pc = &clauses, c = clauses; c ; c = *pc)
+  {
+    bool remove = false;
+
+    switch (ACC_CLAUSE_CODE (c))
+    {
+    case ACC_CLAUSE_PRIVATE:
+      name = "private";
+      goto check_dup_generic;
+    case ACC_CLAUSE_REDUCTION:
+      name = "reduction";
+      goto check_dup_generic;
+    case ACC_CLAUSE_CREATE:
+      name = "create";
+      goto check_dup_generic;
+    case ACC_CLAUSE_COPY:
+      name = "copy";
+      goto check_dup_generic;
+    case ACC_CLAUSE_COPYIN:
+      name = "copyin";
+      goto check_dup_generic;
+    case ACC_CLAUSE_COPYOUT:
+      name = "copyout";
+      goto check_dup_generic;
+    case ACC_CLAUSE_PRESENT:
+      name = "present";
+      goto check_dup_generic;
+    case ACC_CLAUSE_PRESENT_OR_COPY:
+      name = "present_or_copy";
+      goto check_dup_generic;
+    case ACC_CLAUSE_PRESENT_OR_COPYIN:
+      name = "present_or_copyin";
+      goto check_dup_generic;
+    case ACC_CLAUSE_PRESENT_OR_COPYOUT:
+      name = "present_or_copyout";
+      goto check_dup_generic;
+    check_dup_generic:
+      t = ACC_CLAUSE_DECL (c);
+      if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
+      {
+        if (processing_template_decl)
+          break;
+        if (DECL_P (t))
+          error ("%qD is not a variable in clause %qs", t, name);
+        else
+          error ("%qE is not a variable in clause %qs", t, name);
+        remove = true;
+      }
+      else if (bitmap_bit_p (&generic_head, DECL_UID (t))
+               || bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
+      {
+        error ("%qD appears more than once in data clauses", t);
+        remove = true;
+      }
+      else
+        bitmap_set_bit (&generic_head, DECL_UID (t));
+      break;
+
+    case ACC_CLAUSE_FIRSTPRIVATE:
+      t = ACC_CLAUSE_DECL (c);
+      if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
+      {
+        if (processing_template_decl)
+          break;
+        if (DECL_P (t))
+          error ("%qD is not a variable in clause %<firstprivate%>", t);
+        else
+          error ("%qE is not a variable in clause %<firstprivate%>", t);
+        remove = true;
+      }
+      else if (bitmap_bit_p (&generic_head, DECL_UID (t))
+               || bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
+      {
+        error ("%qD appears more than once in data clauses", t);
+        remove = true;
+      }
+      else
+        bitmap_set_bit (&firstprivate_head, DECL_UID (t));
+      break;
+
+    case ACC_CLAUSE_IF:
+      t = ACC_CLAUSE_IF_EXPR (c);
+      t = maybe_convert_cond (t);
+      if (t == error_mark_node)
+      {
+        remove = true;
+      }
+      else if (!processing_template_decl)
+      {
+        t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
+      }
+      ACC_CLAUSE_IF_EXPR (c) = t;
+      break;
+
+    case ACC_CLAUSE_NUM_GANGS:
+      t = ACC_CLAUSE_NUM_GANGS_EXPR (c);
+      if (t == error_mark_node)
+      {
+        remove = true;
+      }
+      else if (!type_dependent_expression_p (t)
+               && !INTEGRAL_TYPE_P (TREE_TYPE (t)))
+      {
+        error ("num_gangs expression must be integral");
+        remove = true;
+      }
+      else
+      {
+        t = mark_rvalue_use (t);
+        if (!processing_template_decl)
+          t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
+        ACC_CLAUSE_NUM_GANGS_EXPR (c) = t;
+      }
+      break;
+
+    case ACC_CLAUSE_NUM_WORKERS:
+      t = ACC_CLAUSE_NUM_WORKERS_EXPR (c);
+      if (t == error_mark_node)
+      {
+        remove = true;
+      }
+      else if (!type_dependent_expression_p (t)
+               && !INTEGRAL_TYPE_P (TREE_TYPE (t)))
+      {
+        error ("num_workers expression must be integral");
+        remove = true;
+      }
+      else
+      {
+        t = mark_rvalue_use (t);
+        if (!processing_template_decl)
+          t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
+        ACC_CLAUSE_NUM_WORKERS_EXPR (c) = t;
+      }
+      break;
+
+    case ACC_CLAUSE_VECTOR_LENGTH:
+      t = ACC_CLAUSE_VECTOR_LENGTH_EXPR (c);
+      if (t == error_mark_node)
+      {
+        remove = true;
+      }
+      else if (!type_dependent_expression_p (t)
+               && !INTEGRAL_TYPE_P (TREE_TYPE (t)))
+      {
+        error ("vector_length expression must be integral");
+        remove = true;
+      }
+      else
+      {
+        t = mark_rvalue_use (t);
+        if (!processing_template_decl)
+          t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
+        ACC_CLAUSE_VECTOR_LENGTH_EXPR (c) = t;
+      }
+      break;
+
+    case ACC_CLAUSE_INDEPENDENT:
+    case ACC_CLAUSE_SEQ:
+      break;
+
+
+    default:
+      gcc_unreachable ();
+    }
+
+    if (remove)
+      *pc = ACC_CLAUSE_CHAIN (c);
+    else
+      pc = &ACC_CLAUSE_CHAIN (c);
+  }
+
+  for (pc = &clauses, c = clauses; c ; c = *pc)
+  {
+    enum acc_clause_code c_kind = ACC_CLAUSE_CODE (c);
+    bool remove = false;
+    bool need_complete_non_reference = false;
+    bool need_default_ctor = false;
+    bool need_copy_ctor = false;
+    bool need_copy_assignment = false;
+    bool need_implicitly_determined = false;
+    tree type, inner_type;
+/*
+    switch (c_kind)
+      {
+      case OMP_CLAUSE_SHARED:
+        name = "shared";
+        need_implicitly_determined = true;
+        break;
+      case OMP_CLAUSE_PRIVATE:
+        name = "private";
+        need_complete_non_reference = true;
+        need_default_ctor = true;
+        need_implicitly_determined = true;
+        break;
+      case OMP_CLAUSE_FIRSTPRIVATE:
+        name = "firstprivate";
+        need_complete_non_reference = true;
+        need_copy_ctor = true;
+        need_implicitly_determined = true;
+        break;
+      case OMP_CLAUSE_LASTPRIVATE:
+        name = "lastprivate";
+        need_complete_non_reference = true;
+        need_copy_assignment = true;
+        need_implicitly_determined = true;
+        break;
+      case OMP_CLAUSE_REDUCTION:
+        name = "reduction";
+        need_implicitly_determined = true;
+        break;
+      case OMP_CLAUSE_COPYPRIVATE:
+        name = "copyprivate";
+        need_copy_assignment = true;
+        break;
+      case OMP_CLAUSE_COPYIN:
+        name = "copyin";
+        need_copy_assignment = true;
+        break;
+      default:
+        pc = &ACC_CLAUSE_CHAIN (c);
+        continue;
+      }*/pc = &ACC_CLAUSE_CHAIN (c);
+
+    t = ACC_CLAUSE_DECL (c);
+    if (processing_template_decl
+        && !VAR_P (t)
+        && TREE_CODE (t) != PARM_DECL)
+      {
+        pc = &ACC_CLAUSE_CHAIN (c);
+        continue;
+      }
+
+    switch (c_kind)
+      {
+      case ACC_CLAUSE_REDUCTION:
+        if (AGGREGATE_TYPE_P (TREE_TYPE (t))
+            || POINTER_TYPE_P (TREE_TYPE (t)))
+          {
+            error ("%qE has invalid type for %<reduction%>", t);
+            remove = true;
+          }
+        else if (FLOAT_TYPE_P (TREE_TYPE (t)))
+          {
+            enum tree_code r_code = ACC_CLAUSE_REDUCTION_CODE (c);
+            switch (r_code)
+              {
+              case PLUS_EXPR:
+              case MULT_EXPR:
+              case MINUS_EXPR:
+              case MIN_EXPR:
+              case MAX_EXPR:
+                break;
+              default:
+                error ("%qE has invalid type for %<reduction(%s)%>",
+                       t, operator_name_info[r_code].name);
+                remove = true;
+              }
+          }
+        break;
+
+      case ACC_CLAUSE_COPYIN:
+        /*if (!VAR_P (t) || !DECL_THREAD_LOCAL_P (t))
+          {
+            error ("%qE must be %<private%> for %<copyin%>", t);
+            remove = true;
+          }*/
+        break;
+
+      default:
+        break;
+      }
+
+    if (need_complete_non_reference || need_copy_assignment)
+    {
+      t = require_complete_type (t);
+      if (t == error_mark_node)
+      {
+        remove = true;
+      }
+      else if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE
+               && need_complete_non_reference)
+      {
+        error ("%qE has reference type for %qs", t, name);
+        remove = true;
+      }
+    }
+
+    /* We're interested in the base element, not arrays.  */
+    inner_type = type = TREE_TYPE (t);
+    while (TREE_CODE (inner_type) == ARRAY_TYPE)
+    {
+      inner_type = TREE_TYPE (inner_type);
+    }
+
+    /* Check for special function availability by building a call to one.
+       Save the results, because later we won't be in the right context
+       for making these queries.  */
+    if (CLASS_TYPE_P (inner_type)
+        && COMPLETE_TYPE_P (inner_type)
+        && (need_default_ctor || need_copy_ctor || need_copy_assignment)
+        && !type_dependent_expression_p (t)
+        && cxx_acc_create_clause_info (c, inner_type, need_default_ctor,
+                                       need_copy_ctor, need_copy_assignment))
+    {
+      remove = true;
+    }
+
+    if (remove)
+      *pc = ACC_CLAUSE_CHAIN (c);
+    else
+      pc = &ACC_CLAUSE_CHAIN (c);
+  }
+
+  bitmap_obstack_release (NULL);
+  return clauses;
+}
+
+
+/********************** OpenACC parsing routines ******************************/
+/******************************************************************************/
+
+
 /* Create CP_OMP_CLAUSE_INFO for clause C.  Returns true if it is invalid.  */
 
 bool
diff --git a/gcc/diagnose-gotos.c b/gcc/diagnose-gotos.c
new file mode 100644
index 00000000000..ee872d1d17c
--- /dev/null
+++ b/gcc/diagnose-gotos.c
@@ -0,0 +1,228 @@
+/* 
+   This file is part of GCC.
+
+   GCC 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 3, or (at your option) any later
+   version.
+
+   GCC 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 GCC; see the file COPYING3.  If not see
+   <http://www.gnu.org/licenses/>.  */
+
+/* Diagnose branches to/from structured pragma regions 
+   based on pass_diagnose_omp_blocks */
+
+
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
+#include "gimple.h"
+#include "tree-iterator.h"
+#include "splay-tree.h"
+#include "diagnose-gotos.h"
+
+#define WALK_SUBSTMTS  \
+  case GIMPLE_BIND: \
+case GIMPLE_TRY: \
+case GIMPLE_CATCH: \
+case GIMPLE_EH_FILTER: \
+case GIMPLE_TRANSACTION: \
+/* The sub-statements for these should be walked.  */ \
+*handled_ops_p = false; \
+break;
+
+static splay_tree all_labels;
+
+struct diagnose_context
+{
+  gimple stmt;
+  vec<enum gimple_code>* codes;
+  recursive_seq_callback rcb;
+  diagnose_context_callback dcb;
+};
+
+/* Pass 1: Create a map of each label definitions  */
+
+static tree
+diagnose_sb_1 (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
+               struct walk_stmt_info *wi)
+{
+  struct diagnose_context* context = (struct diagnose_context*) wi->info;
+  gimple save_context;
+  gimple stmt = gsi_stmt (*gsi_p);
+
+  *handled_ops_p = true;
+
+  switch (gimple_code (stmt))
+    {
+      WALK_SUBSTMTS;
+
+    case GIMPLE_LABEL:
+      splay_tree_insert (all_labels, (splay_tree_key) gimple_label_label (stmt),
+                         (splay_tree_value) context->stmt);
+      break;
+
+    default:
+        {
+          unsigned i, j;
+          vec<enum gimple_code>* codes = context->codes;
+
+          for(i = 0; i < codes->length(); ++i) {
+              if((*codes)[i] == gimple_code(stmt)) {
+                  break;
+              }
+          }
+          if(i < codes->length()) {
+              vec<gimple_seq*> recurse;
+              recurse.create(3);
+              context->rcb((*codes)[i], stmt, &recurse);
+
+              save_context = context->stmt;
+              context->stmt = stmt;
+              for(j = 0; j < recurse.length(); ++j) {
+                  gimple_seq seq = *recurse[j];
+                  walk_gimple_seq(seq, diagnose_sb_1, NULL, wi);
+              }
+              context->stmt = save_context;
+          }
+        }
+      break;
+    }
+
+  return NULL_TREE;
+}
+
+/* Pass 2: Check each branch and see if its context differs from that of
+   the destination label's context.  */
+
+static tree
+diagnose_sb_2 (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
+               struct walk_stmt_info *wi)
+{
+  struct diagnose_context* context = (struct diagnose_context*) wi->info;
+  gimple save_context;
+  splay_tree_node n;
+  gimple stmt = gsi_stmt (*gsi_p);
+
+  *handled_ops_p = true;
+
+  switch (gimple_code (stmt))
+    {
+      WALK_SUBSTMTS;
+
+    case GIMPLE_COND:
+        {
+          tree lab = gimple_cond_true_label (stmt);
+          if (lab)
+            {
+              n = splay_tree_lookup (all_labels,
+                                     (splay_tree_key) lab);
+              context->dcb (gsi_p, context->stmt,
+                            n ? (gimple) n->value : NULL);
+            }
+          lab = gimple_cond_false_label (stmt);
+          if (lab)
+            {
+              n = splay_tree_lookup (all_labels,
+                                     (splay_tree_key) lab);
+              context->dcb (gsi_p, context->stmt,
+                            n ? (gimple) n->value : NULL);
+            }
+        }
+      break;
+
+    case GIMPLE_GOTO:
+        {
+          tree lab = gimple_goto_dest (stmt);
+          if (TREE_CODE (lab) != LABEL_DECL)
+            break;
+
+          n = splay_tree_lookup (all_labels, (splay_tree_key) lab);
+          context->dcb (gsi_p, context->stmt, n ? (gimple) n->value : NULL);
+        }
+      break;
+
+    case GIMPLE_SWITCH:
+        {
+          unsigned int i;
+          for (i = 0; i < gimple_switch_num_labels (stmt); ++i)
+            {
+              tree lab = CASE_LABEL (gimple_switch_label (stmt, i));
+              n = splay_tree_lookup (all_labels, (splay_tree_key) lab);
+              if (n && context->dcb (gsi_p, context->stmt, (gimple) n->value))
+                break;
+            }
+        }
+      break;
+
+    case GIMPLE_RETURN:
+      context->dcb (gsi_p, context->stmt, NULL);
+      break;
+
+    default:
+        {
+          unsigned i, j;
+          vec<enum gimple_code>* codes = context->codes;
+
+          for(i = 0; i < codes->length(); ++i) {
+              if((*codes)[i] == gimple_code(stmt)) {
+                  break;
+              }
+          }
+          if(i < codes->length()) {
+              vec<gimple_seq*> recurse;
+              recurse.create(3);
+              context->rcb((*codes)[i], stmt, &recurse);
+
+              save_context = context->stmt;
+              context->stmt = stmt;
+              for(j = 0; j < recurse.length(); ++j) {
+                  gimple_seq* seq = recurse[j];
+                  walk_gimple_seq_mod(seq, diagnose_sb_2, NULL, wi);
+              }
+              context->stmt = save_context;
+          }
+        }
+      break;
+    }
+
+  return NULL_TREE;
+}
+
+
+void
+diagnose_gotos(vec<enum gimple_code>* codes, recursive_seq_callback rcb, diagnose_context_callback dcb)
+{
+  struct diagnose_context ctx;
+  struct walk_stmt_info wi;
+  gimple_seq body = gimple_body (current_function_decl);
+
+  all_labels = splay_tree_new (splay_tree_compare_pointers, 0, 0);
+
+  memset(&ctx, 0, sizeof(ctx));
+  ctx.codes = codes;
+  ctx.rcb = rcb;
+  ctx.dcb = dcb;
+
+  memset (&wi, 0, sizeof (wi));
+  wi.info = &ctx;
+  walk_gimple_seq (body, diagnose_sb_1, NULL, &wi);
+
+  memset (&wi, 0, sizeof (wi));
+  wi.want_locations = true;
+  wi.info = &ctx;
+  walk_gimple_seq_mod (&body, diagnose_sb_2, NULL, &wi);
+
+  gimple_set_body (current_function_decl, body);
+
+  splay_tree_delete (all_labels);
+  all_labels = NULL;
+}
+
diff --git a/gcc/diagnose-gotos.h b/gcc/diagnose-gotos.h
new file mode 100644
index 00000000000..dd554a90235
--- /dev/null
+++ b/gcc/diagnose-gotos.h
@@ -0,0 +1,46 @@
+/*
+   This file is part of GCC.
+
+   GCC 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 3, or (at your option) any later
+   version.
+
+   GCC 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 GCC; see the file COPYING3.  If not see
+   <http://www.gnu.org/licenses/>.  */
+/* Diagnose branches to/from structured pragma regions
+   based on pass_diagnose_omp_blocks */
+
+#ifndef DIAGNOSE_GOTOS_H
+#define DIAGNOSE_GOTOS_H
+
+/*
+   Diagnostic callback signature.
+   GSI is a statement iterator of branch in question,
+   BRANCH_CONTEXT is a gimple statement in wich context branch occures or NULL if outside of any region,
+   LABEL_CONTEXT is a gimple statement in with context branch tragets or NULL if outside of any regions.
+   This callback compares contexts and issues error and replace stmt with NOP if needed
+ */
+typedef bool (*diagnose_context_callback) (gimple_stmt_iterator* gsi, gimple branch_context, gimple label_context);
+/*
+   Recursive structure callback signature.
+   CODE is a GIMPLE code and STMT is a statement in question,
+   SEQ is a pointer to initialized vector.
+   This callback must fill given vector with sequence pointers to substructures of STMT
+ */
+typedef void (*recursive_seq_callback) (enum gimple_code code, gimple stmt, vec<gimple_seq*>* seq);
+
+/*
+   Perform validation of branches to/from structured pragma blocks.
+   CODES is a vec of interesting codes, 
+   RCB and DCB - callback pointers.
+ */
+extern void diagnose_gotos(vec<enum gimple_code>* codes, recursive_seq_callback rcb, diagnose_context_callback dcb);
+
+#endif
diff --git a/gcc/fortran/Make-lang.in b/gcc/fortran/Make-lang.in
index 47deca61c6f..7e8b379e227 100644
--- a/gcc/fortran/Make-lang.in
+++ b/gcc/fortran/Make-lang.in
@@ -58,14 +58,15 @@ F95_PARSER_OBJS = fortran/arith.o fortran/array.o fortran/bbt.o \
     fortran/iresolve.o fortran/match.o fortran/matchexp.o fortran/misc.o \
     fortran/module.o fortran/openmp.o fortran/options.o fortran/parse.o \
     fortran/primary.o fortran/resolve.o fortran/scanner.o fortran/simplify.o \
-    fortran/st.o fortran/symbol.o fortran/target-memory.o
+    fortran/st.o fortran/symbol.o fortran/target-memory.o fortran/openacc.o
 
 F95_OBJS = $(F95_PARSER_OBJS) $(FORTRAN_TARGET_OBJS) \
     fortran/convert.o fortran/dependency.o fortran/f95-lang.o \
     fortran/trans.o fortran/trans-array.o fortran/trans-common.o \
     fortran/trans-const.o fortran/trans-decl.o fortran/trans-expr.o \
     fortran/trans-intrinsic.o fortran/trans-io.o fortran/trans-openmp.o \
-    fortran/trans-stmt.o fortran/trans-types.o fortran/frontend-passes.o
+    fortran/trans-stmt.o fortran/trans-types.o fortran/frontend-passes.o \
+    fortran/trans-openacc.o
 
 fortran_OBJS = $(F95_OBJS) gfortranspec.o
 
@@ -327,6 +328,7 @@ $(F95_PARSER_OBJS): fortran/gfortran.h fortran/libgfortran.h \
 		$(FLAGS_H) $(DIAGNOSTIC_H) errors.h $(FUNCTION_H) \
 		fortran/iso-c-binding.def fortran/iso-fortran-env.def
 fortran/openmp.o: pointer-set.h $(TARGET_H) toplev.h
+fortran/openacc.o: pointer-set.h $(TARGET_H) toplev.h
 
 GFORTRAN_TRANS_DEPS = fortran/gfortran.h fortran/libgfortran.h \
     fortran/intrinsic.h fortran/trans-array.h \
@@ -354,6 +356,7 @@ fortran/trans-const.o: $(GFORTRAN_TRANS_DEPS) realmpfr.h
 fortran/trans-expr.o: $(GFORTRAN_TRANS_DEPS) fortran/dependency.h
 fortran/trans-stmt.o: $(GFORTRAN_TRANS_DEPS) fortran/dependency.h
 fortran/trans-openmp.o: $(GFORTRAN_TRANS_DEPS)
+fortran/trans-openacc.o: $(GFORTRAN_TRANS_DEPS)
 fortran/trans-io.o: $(GFORTRAN_TRANS_DEPS) gt-fortran-trans-io.h \
   fortran/ioparm.def
 fortran/trans-array.o: $(GFORTRAN_TRANS_DEPS) $(GIMPLE_H)
diff --git a/gcc/fortran/decl.c b/gcc/fortran/decl.c
index 152511962d9..f00bd0a3278 100644
--- a/gcc/fortran/decl.c
+++ b/gcc/fortran/decl.c
@@ -5992,6 +5992,7 @@ gfc_match_end (gfc_statement *st)
 
     case COMP_CONTAINS:
     case COMP_DERIVED_CONTAINS:
+    case COMP_ACC_STRUCTURED_BLOCK:
       state = gfc_state_stack->previous->state;
       block_name = gfc_state_stack->previous->sym == NULL
 		 ? NULL : gfc_state_stack->previous->sym->name;
diff --git a/gcc/fortran/dump-parse-tree.c b/gcc/fortran/dump-parse-tree.c
index 14ff0041219..add2995c19e 100644
--- a/gcc/fortran/dump-parse-tree.c
+++ b/gcc/fortran/dump-parse-tree.c
@@ -1015,11 +1015,36 @@ show_code (int level, gfc_code *c)
 }
 
 static void
+show_subarray (const char *name, struct gfc_acc_subarray* sa)
+{
+  int i = 0;
+
+  fprintf (dumpfile, "%s(", name);
+  for (; i < sa->dimensions; i++)
+    {
+      show_expr(sa->left[i]);
+      fputc(':', dumpfile);
+      show_expr(sa->right[i]);
+      if (i == sa->dimensions - 1)
+        fputc(')', dumpfile);
+      else
+        fputc(',', dumpfile);
+    }
+}
+
+static void
 show_namelist (gfc_namelist *n)
 {
   for (; n->next; n = n->next)
-    fprintf (dumpfile, "%s,", n->sym->name);
-  fprintf (dumpfile, "%s", n->sym->name);
+    if (n->acc_subarray == NULL)
+      fprintf (dumpfile, "%s,", n->sym->name);
+    else
+      show_subarray (n->sym->name, n->acc_subarray);
+
+  if (n->acc_subarray == NULL)
+    fprintf (dumpfile, "%s", n->sym->name);
+  else
+    show_subarray (n->sym->name, n->acc_subarray);
 }
 
 /* Show a single OpenMP directive node and everything underneath it
@@ -1230,6 +1255,197 @@ show_omp_node (int level, gfc_code *c)
     fprintf (dumpfile, " (%s)", c->ext.omp_name);
 }
 
+/* Show a single OpenACC directive node and everything underneath it
+   if necessary.  */
+
+static void
+show_acc_node (int level, gfc_code *c)
+{
+  gfc_acc_clauses *acc_clauses = NULL;
+  const char *name = NULL;
+
+  switch (c->op)
+    {
+    case EXEC_ACC_PARALLEL_LOOP: name = "PARALLEL LOOP"; break;
+    case EXEC_ACC_PARALLEL: name = "PARALLEL"; break;
+    case EXEC_ACC_KERNELS_LOOP: name = "KERNELS LOOP"; break;
+    case EXEC_ACC_KERNELS: name = "KERNELS"; break;
+    case EXEC_ACC_DATA: name = "DATA"; break;
+    case EXEC_ACC_HOST_DATA: name = "HOST_DATA"; break;
+    case EXEC_ACC_LOOP: name = "LOOP"; break;
+    case EXEC_ACC_UPDATE: name = "UPDATE"; break;
+    case EXEC_ACC_WAIT: name = "WAIT"; break;
+    case EXEC_ACC_CACHE: name = "CACHE"; break;
+    default:
+      gcc_unreachable ();
+    }
+  fprintf (dumpfile, "!$ACC %s", name);
+  switch (c->op)
+    {
+    case EXEC_ACC_CACHE:
+    case EXEC_ACC_WAIT:
+    case EXEC_ACC_UPDATE:
+    case EXEC_ACC_LOOP:
+    case EXEC_ACC_HOST_DATA:
+    case EXEC_ACC_DATA:
+    case EXEC_ACC_KERNELS:
+    case EXEC_ACC_KERNELS_LOOP:
+    case EXEC_ACC_PARALLEL:
+    case EXEC_ACC_PARALLEL_LOOP:
+      acc_clauses = c->ext.acc_clauses;
+      break;
+    default:
+      break;
+    }
+  if (acc_clauses)
+    {
+      int list;
+
+      if (acc_clauses->if_expr)
+        {
+          fputs (" IF(", dumpfile);
+          show_expr (acc_clauses->if_expr);
+          fputc (')', dumpfile);
+        }
+      if (acc_clauses->async)
+        {
+          fputs (" ASYNC", dumpfile);
+          if (acc_clauses->async_expr)
+            {
+              fputc ('(', dumpfile);
+              show_expr (acc_clauses->async_expr);
+              fputc (')', dumpfile);
+            }
+        }
+      if (acc_clauses->num_gangs_expr)
+        {
+          fputs (" NUM_GANGS(", dumpfile);
+          show_expr (acc_clauses->num_gangs_expr);
+          fputc (')', dumpfile);
+        }
+      if (acc_clauses->num_workers_expr)
+        {
+          fputs (" NUM_WORKERS(", dumpfile);
+          show_expr (acc_clauses->num_workers_expr);
+          fputc (')', dumpfile);
+        }
+      if (acc_clauses->vector_length_expr)
+        {
+          fputs (" VECTOR_LENGTH(", dumpfile);
+          show_expr (acc_clauses->vector_length_expr);
+          fputc (')', dumpfile);
+        }
+      if (acc_clauses->collapse)
+        {
+          fputs (" COLLAPSE(", dumpfile);
+          fprintf (dumpfile, "%d", acc_clauses->collapse);
+          fputc (')', dumpfile);
+        }
+      if (acc_clauses->gang)
+        {
+          fputs (" GANG", dumpfile);
+          if (acc_clauses->gang_expr)
+            {
+              fputc ('(', dumpfile);
+              show_expr (acc_clauses->gang_expr);
+              fputc (')', dumpfile);
+            }
+        }
+      if (acc_clauses->worker)
+        {
+          fputs (" WORKER", dumpfile);
+          if (acc_clauses->worker_expr)
+            {
+              fputc ('(', dumpfile);
+              show_expr (acc_clauses->worker_expr);
+              fputc (')', dumpfile);
+            }
+        }
+      if (acc_clauses->vector)
+        {
+          fputs (" VECTOR", dumpfile);
+          if (acc_clauses->vector_expr)
+            {
+              fputc ('(', dumpfile);
+              show_expr (acc_clauses->vector_expr);
+              fputc (')', dumpfile);
+            }
+        }
+      if (acc_clauses->wait_expr)
+        {
+          fputc ('(', dumpfile);
+          show_expr (acc_clauses->wait_expr);
+          fputc (')', dumpfile);
+        }
+      if (acc_clauses->seq)
+        fputs (" SEQ", dumpfile);
+      if (acc_clauses->independent)
+        fputs (" INDEPENDENT", dumpfile);
+      for (list = 0; list < ACC_LIST_NUM; list++)
+        if (acc_clauses->lists[list] != NULL)
+          {
+            const char *name;
+            if (list < ACC_LIST_REDUCTION_FIRST)
+              {
+                switch (list)
+                  {
+                  case ACC_LIST_COPY: name = "COPY"; break;
+                  case ACC_LIST_COPYIN: name = "COPYIN"; break;
+                  case ACC_LIST_COPYOUT: name = "COPYOUT"; break;
+                  case ACC_LIST_CREATE: name = "CREATE"; break;
+                  case ACC_LIST_PRESENT: name = "PRESENT"; break;
+                  case ACC_LIST_PRESENT_OR_COPY: name = "PRESENT_OR_COPY"; break;
+                  case ACC_LIST_PRESENT_OR_COPYIN: name = "PRESENT_OR_COPYIN"; break;
+                  case ACC_LIST_PRESENT_OR_COPYOUT: name = "PRESENT_OR_COPYOUT"; break;
+                  case ACC_LIST_PRESENT_OR_CREATE: name = "PRESENT_OR_CREATE"; break;
+                  case ACC_LIST_DEVICEPTR: name = "DEVICEPTR"; break;
+                  case ACC_LIST_PRIVATE: name = "PRIVATE"; break;
+                  case ACC_LIST_FIRSTPRIVATE: name = "FIRSTPRIVATE"; break;
+                  case ACC_LIST_USE_DEVICE: name = "USE_DEVICE"; break;
+                  case ACC_LIST_DEVICE_RESIDENT: name = "USE_DEVICE"; break;
+                  case ACC_LIST_HOST: name = "HOST"; break;
+                  case ACC_LIST_DEVICE: name = "DEVICE"; break;
+                  case ACC_LIST_CACHE: name = ""; break;
+                  default:
+                    gcc_unreachable ();
+                  }
+                fprintf (dumpfile, " %s(", name);
+              }
+            else
+              {
+                switch (list)
+                  {
+                  case ACC_LIST_PLUS: name = "+"; break;
+                  case ACC_LIST_MULT: name = "*"; break;
+                  case ACC_LIST_SUB: name = "-"; break;
+                  case ACC_LIST_AND: name = ".AND."; break;
+                  case ACC_LIST_OR: name = ".OR."; break;
+                  case ACC_LIST_EQV: name = ".EQV."; break;
+                  case ACC_LIST_NEQV: name = ".NEQV."; break;
+                  case ACC_LIST_MAX: name = "MAX"; break;
+                  case ACC_LIST_MIN: name = "MIN"; break;
+                  case ACC_LIST_IAND: name = "IAND"; break;
+                  case ACC_LIST_IOR: name = "IOR"; break;
+                  case ACC_LIST_IEOR: name = "IEOR"; break;
+                  default:
+                    gcc_unreachable ();
+                  }
+                fprintf (dumpfile, " REDUCTION(%s:", name);
+              }
+            show_namelist (acc_clauses->lists[list]);
+            fputc (')', dumpfile);
+          }
+    }
+  if (c->op == EXEC_ACC_UPDATE || c->op == EXEC_ACC_WAIT
+      || c->op == EXEC_ACC_CACHE)
+    return;
+  show_code (level + 1, c->block->next);
+  fputc ('\n', dumpfile);
+  if (c->op == EXEC_ACC_LOOP)
+    return;
+  code_indent (level, 0);
+  fprintf (dumpfile, "!$ACC END %s", name);
+}
 
 /* Show a single code node and everything underneath it if necessary.  */
 
@@ -2213,6 +2429,19 @@ show_code_node (int level, gfc_code *c)
       show_omp_node (level, c);
       break;
 
+    case EXEC_ACC_PARALLEL_LOOP:
+    case EXEC_ACC_PARALLEL:
+    case EXEC_ACC_KERNELS_LOOP:
+    case EXEC_ACC_KERNELS:
+    case EXEC_ACC_DATA:
+    case EXEC_ACC_HOST_DATA:
+    case EXEC_ACC_LOOP:
+    case EXEC_ACC_UPDATE:
+    case EXEC_ACC_WAIT:
+    case EXEC_ACC_CACHE:
+      show_acc_node (level, c);
+      break;
+
     default:
       gfc_internal_error ("show_code_node(): Bad statement code");
     }
diff --git a/gcc/fortran/f95-lang.c b/gcc/fortran/f95-lang.c
index 7bb2913552c..2dbb7eb25c7 100644
--- a/gcc/fortran/f95-lang.c
+++ b/gcc/fortran/f95-lang.c
@@ -1029,6 +1029,15 @@ gfc_init_builtin_functions (void)
 #undef DEF_GOMP_BUILTIN
     }
 
+	if(gfc_option.gfc_flag_openacc) {
+#undef DEF_OACC_BUILTIN
+#define DEF_OACC_BUILTIN(code, name, type, attr) \
+      gfc_define_builtin ("__builtin_" name, builtin_types[type], \
+			  code, name, attr);
+#include "../oacc-builtins.def"
+#undef DEF_OACC_BUILTIN
+	}
+
   gfc_define_builtin ("__builtin_trap", builtin_types[BT_FN_VOID],
 		      BUILT_IN_TRAP, NULL, ATTR_NOTHROW_LEAF_LIST);
   TREE_THIS_VOLATILE (builtin_decl_explicit (BUILT_IN_TRAP)) = 1;
diff --git a/gcc/fortran/gfortran.h b/gcc/fortran/gfortran.h
index b28edd80002..e60f5d5305c 100644
--- a/gcc/fortran/gfortran.h
+++ b/gcc/fortran/gfortran.h
@@ -211,7 +211,11 @@ typedef enum
   ST_OMP_PARALLEL, ST_OMP_PARALLEL_DO, ST_OMP_PARALLEL_SECTIONS,
   ST_OMP_PARALLEL_WORKSHARE, ST_OMP_SECTIONS, ST_OMP_SECTION, ST_OMP_SINGLE,
   ST_OMP_THREADPRIVATE, ST_OMP_WORKSHARE, ST_OMP_TASK, ST_OMP_END_TASK,
-  ST_OMP_TASKWAIT, ST_OMP_TASKYIELD, ST_PROCEDURE, ST_GENERIC, ST_CRITICAL,
+  ST_OMP_TASKWAIT, ST_OMP_TASKYIELD, ST_ACC_PARALLEL_LOOP, ST_ACC_END_PARALLEL_LOOP,
+  ST_ACC_PARALLEL, ST_ACC_END_PARALLEL, ST_ACC_KERNELS, ST_ACC_END_KERNELS,
+  ST_ACC_DATA, ST_ACC_END_DATA, ST_ACC_HOST_DATA, ST_ACC_END_HOST_DATA, ST_ACC_LOOP,
+  ST_ACC_DECLARE, ST_ACC_UPDATE, ST_ACC_WAIT, ST_ACC_CACHE, ST_ACC_KERNELS_LOOP,
+  ST_ACC_END_KERNELS_LOOP, ST_PROCEDURE, ST_GENERIC, ST_CRITICAL,
   ST_END_CRITICAL, ST_GET_FCN_CHARACTERISTICS, ST_LOCK, ST_UNLOCK, ST_NONE
 }
 gfc_statement;
@@ -1013,6 +1017,16 @@ gfc_actual_arglist;
 
 #define gfc_get_actual_arglist() XCNEW (gfc_actual_arglist)
 
+/* Used only in OpenACC, since we cannot use array range ref */
+struct gfc_acc_subarray
+{
+  int dimensions;
+
+  /* Subarray range boundaries */
+  gfc_expr *left[GFC_MAX_DIMENSIONS], *right[GFC_MAX_DIMENSIONS];
+};
+
+#define gfc_get_acc_subarray() XCNEW (struct gfc_acc_subarray)
 
 /* Because a symbol can belong to multiple namelists, they must be
    linked externally to the symbol itself.  */
@@ -1020,6 +1034,7 @@ typedef struct gfc_namelist
 {
   struct gfc_symbol *sym;
   struct gfc_namelist *next;
+  struct gfc_acc_subarray *acc_subarray;
 }
 gfc_namelist;
 
@@ -1050,6 +1065,49 @@ enum
   OMP_LIST_NUM
 };
 
+enum
+{
+  ACC_LIST_COPY,
+  ACC_LIST_DATA_CLAUSE_FIRST = ACC_LIST_COPY,
+  ACC_LIST_COPYIN,
+  ACC_LIST_COPYOUT,
+  ACC_LIST_CREATE,
+  ACC_LIST_PRESENT,
+
+  ACC_LIST_PRESENT_OR_COPY,
+  ACC_LIST_PRESENT_OR_COPYIN,
+  ACC_LIST_PRESENT_OR_COPYOUT,
+  ACC_LIST_PRESENT_OR_CREATE,
+  ACC_LIST_DEVICEPTR,
+  ACC_LIST_DATA_CLAUSE_LAST = ACC_LIST_DEVICEPTR,
+
+  ACC_LIST_PRIVATE,
+  ACC_LIST_FIRSTPRIVATE,
+  ACC_LIST_USE_DEVICE,
+  ACC_LIST_DEVICE_RESIDENT,
+  ACC_LIST_HOST,
+
+  ACC_LIST_DEVICE,
+  ACC_LIST_CACHE,
+  ACC_LIST_PLUS,
+  ACC_LIST_REDUCTION_FIRST = ACC_LIST_PLUS,
+  ACC_LIST_MULT,
+  ACC_LIST_SUB,
+
+  ACC_LIST_AND,
+  ACC_LIST_OR,
+  ACC_LIST_EQV,
+  ACC_LIST_NEQV,
+  ACC_LIST_MAX,
+
+  ACC_LIST_MIN,
+  ACC_LIST_IAND,
+  ACC_LIST_IOR,
+  ACC_LIST_IEOR,
+  ACC_LIST_REDUCTION_LAST = ACC_LIST_IEOR,
+  ACC_LIST_NUM
+};
+
 /* Because a symbol can belong to multiple namelists, they must be
    linked externally to the symbol itself.  */
 
@@ -1088,6 +1146,25 @@ gfc_omp_clauses;
 
 #define gfc_get_omp_clauses() XCNEW (gfc_omp_clauses)
 
+/* OpenACC */
+typedef struct gfc_acc_clauses
+{
+  struct gfc_expr *if_expr;
+  struct gfc_expr *async_expr;
+  struct gfc_expr *gang_expr;
+  struct gfc_expr *worker_expr;
+  struct gfc_expr *vector_expr;
+  struct gfc_expr *num_gangs_expr;
+  struct gfc_expr *num_workers_expr;
+  struct gfc_expr *vector_length_expr;
+  struct gfc_expr *wait_expr;
+  gfc_namelist *lists[ACC_LIST_NUM];
+  int collapse;
+  bool async, gang, worker, vector, seq, independent;
+}
+gfc_acc_clauses;
+
+#define gfc_get_acc_clauses() XCNEW (gfc_acc_clauses)
 
 /* The gfc_st_label structure is a BBT attached to a namespace that
    records the usage of statement labels within that space.  */
@@ -1444,6 +1521,9 @@ typedef struct gfc_namespace
      this namespace.  */
   struct gfc_data *data;
 
+  /* !$ACC DECLARE clauses */
+  gfc_acc_clauses *declare_clauses;
+
   gfc_charlen *cl_list, *old_cl_list;
 
   gfc_dt_list *derived_types;
@@ -2108,7 +2188,9 @@ typedef enum
   EXEC_OMP_SECTIONS, EXEC_OMP_SINGLE, EXEC_OMP_WORKSHARE,
   EXEC_OMP_ATOMIC, EXEC_OMP_BARRIER, EXEC_OMP_END_NOWAIT,
   EXEC_OMP_END_SINGLE, EXEC_OMP_TASK, EXEC_OMP_TASKWAIT,
-  EXEC_OMP_TASKYIELD
+  EXEC_OMP_TASKYIELD, EXEC_ACC_KERNELS_LOOP,
+  EXEC_ACC_PARALLEL_LOOP, EXEC_ACC_PARALLEL, EXEC_ACC_KERNELS, EXEC_ACC_DATA,
+  EXEC_ACC_HOST_DATA, EXEC_ACC_LOOP, EXEC_ACC_UPDATE, EXEC_ACC_WAIT, EXEC_ACC_CACHE
 }
 gfc_exec_op;
 
@@ -2168,6 +2250,7 @@ typedef struct gfc_code
     int stop_code;
     gfc_entry_list *entry;
     gfc_omp_clauses *omp_clauses;
+    gfc_acc_clauses *acc_clauses;
     const char *omp_name;
     gfc_namelist *omp_namelist;
     bool omp_bool;
@@ -2286,6 +2369,7 @@ typedef struct
   int flag_cray_pointer;
   int flag_d_lines;
   int gfc_flag_openmp;
+  int gfc_flag_openacc;
   int flag_sign_zero;
   int flag_stack_arrays;
   int flag_module_private;
@@ -2743,6 +2827,12 @@ void gfc_resolve_omp_do_blocks (gfc_code *, gfc_namespace *);
 void gfc_omp_save_and_clear_state (struct gfc_omp_saved_state *);
 void gfc_omp_restore_state (struct gfc_omp_saved_state *);
 
+/* openacc.c */
+void gfc_free_acc_clauses (gfc_acc_clauses *);
+void gfc_resolve_acc_directive (gfc_code *, gfc_namespace *);
+void gfc_resolve_acc_parallel_loop_blocks (gfc_code *, gfc_namespace *);
+void gfc_resolve_acc_blocks (gfc_code *, gfc_namespace *);
+
 /* expr.c */
 void gfc_free_actual_arglist (gfc_actual_arglist *);
 gfc_actual_arglist *gfc_copy_actual_arglist (gfc_actual_arglist *);
diff --git a/gcc/fortran/lang.opt b/gcc/fortran/lang.opt
index 4f7993433d4..3750cbc5f36 100644
--- a/gcc/fortran/lang.opt
+++ b/gcc/fortran/lang.opt
@@ -517,6 +517,10 @@ fopenmp
 Fortran
 ; Documented in C
 
+fopenacc
+Fortran
+; Documented in C
+
 fpack-derived
 Fortran
 Try to lay out derived types as compactly as possible
diff --git a/gcc/fortran/match.c b/gcc/fortran/match.c
index 71e3862189a..8d47b45772d 100644
--- a/gcc/fortran/match.c
+++ b/gcc/fortran/match.c
@@ -2514,7 +2514,8 @@ match_exit_cycle (gfc_statement st, gfc_exec_op op)
 
   /* Find the loop specified by the label (or lack of a label).  */
   for (o = NULL, p = gfc_state_stack; p; p = p->previous)
-    if (o == NULL && p->state == COMP_OMP_STRUCTURED_BLOCK)
+    if (o == NULL
+        && (p->state == COMP_OMP_STRUCTURED_BLOCK || p->state == COMP_ACC_STRUCTURED_BLOCK))
       o = p;
     else if (p->state == COMP_CRITICAL)
       {
@@ -2593,7 +2594,7 @@ match_exit_cycle (gfc_statement st, gfc_exec_op op)
     o = o->previous;
   if (cnt > 0
       && o != NULL
-      && o->state == COMP_OMP_STRUCTURED_BLOCK
+      && (o->state == COMP_OMP_STRUCTURED_BLOCK || o->state == COMP_ACC_STRUCTURED_BLOCK)
       && (o->head->op == EXEC_OMP_DO
 	  || o->head->op == EXEC_OMP_PARALLEL_DO))
     {
@@ -2618,6 +2619,33 @@ match_exit_cycle (gfc_statement st, gfc_exec_op op)
 	  return MATCH_ERROR;
 	}
     }
+  if (cnt > 0
+      && o != NULL
+      && (o->state == COMP_OMP_STRUCTURED_BLOCK || o->state == COMP_ACC_STRUCTURED_BLOCK)
+      && (o->head->op == EXEC_ACC_LOOP
+          || o->head->op == EXEC_ACC_PARALLEL_LOOP))
+    {
+      int collapse = 1;
+      gcc_assert (o->head->next != NULL
+                  && (o->head->next->op == EXEC_DO
+                      || o->head->next->op == EXEC_DO_WHILE)
+                  && o->previous != NULL
+                  && o->previous->tail->op == o->head->op);
+      if (o->previous->tail->ext.omp_clauses != NULL
+          && o->previous->tail->ext.omp_clauses->collapse > 1)
+        collapse = o->previous->tail->ext.omp_clauses->collapse;
+      if (st == ST_EXIT && cnt <= collapse)
+        {
+          gfc_error ("EXIT statement at %C terminating !$ACC LOOP loop");
+          return MATCH_ERROR;
+        }
+      if (st == ST_CYCLE && cnt < collapse)
+        {
+          gfc_error ("CYCLE statement at %C to non-innermost collapsed"
+                     " !$ACC LOOP loop");
+          return MATCH_ERROR;
+        }
+    }
 
   /* Save the first statement in the construct - needed by the backend.  */
   new_st.ext.which_construct = p->construct;
@@ -4561,6 +4589,8 @@ gfc_free_namelist (gfc_namelist *name)
   for (; name; name = n)
     {
       n = name->next;
+      if (name->acc_subarray)
+        free (name->acc_subarray);
       free (name);
     }
 }
diff --git a/gcc/fortran/match.h b/gcc/fortran/match.h
index 1a701f04f39..190067e0bea 100644
--- a/gcc/fortran/match.h
+++ b/gcc/fortran/match.h
@@ -145,6 +145,21 @@ match gfc_match_omp_workshare (void);
 match gfc_match_omp_end_nowait (void);
 match gfc_match_omp_end_single (void);
 
+/* openacc.h */
+
+match gfc_match_acc_eos (void);
+match gfc_match_acc_cache (void);
+match gfc_match_acc_wait (void);
+match gfc_match_acc_update (void);
+match gfc_match_acc_declare (void);
+match gfc_match_acc_loop (void);
+match gfc_match_acc_host_data (void);
+match gfc_match_acc_data (void);
+match gfc_match_acc_kernels (void);
+match gfc_match_acc_kernels_loop (void);
+match gfc_match_acc_parallel (void);
+match gfc_match_acc_parallel_loop (void);
+
 /* decl.c.  */
 
 match gfc_match_data (void);
diff --git a/gcc/fortran/openacc.c b/gcc/fortran/openacc.c
new file mode 100644
index 00000000000..a4c15bf4853
--- /dev/null
+++ b/gcc/fortran/openacc.c
@@ -0,0 +1,1244 @@
+/* OpenACC directive matching and resolving.
+ */
+
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "flags.h"
+#include "gfortran.h"
+#include "match.h"
+#include "parse.h"
+#include "pointer-set.h"
+#include "arith.h"              /* for gfc_convert_integer */
+
+#define ACC_CLAUSE_IF                   (1l << 0)
+#define ACC_CLAUSE_ASYNC                (1l << 1)
+#define ACC_CLAUSE_NUM_GANGS            (1l << 2)
+#define ACC_CLAUSE_NUM_WORKERS          (1l << 3)
+#define ACC_CLAUSE_VECTOR_LENGTH        (1l << 4)
+#define ACC_CLAUSE_REDUCTION            (1l << 5)
+#define ACC_CLAUSE_COPY                 (1l << 6)
+#define ACC_CLAUSE_COPYIN               (1l << 7)
+#define ACC_CLAUSE_COPYOUT              (1l << 8)
+#define ACC_CLAUSE_CREATE               (1l << 9)
+#define ACC_CLAUSE_PRESENT              (1l << 10)
+#define ACC_CLAUSE_PRESENT_OR_COPY      (1l << 11)
+#define ACC_CLAUSE_PRESENT_OR_COPYIN    (1l << 12)
+#define ACC_CLAUSE_PRESENT_OR_COPYOUT   (1l << 13)
+#define ACC_CLAUSE_PRESENT_OR_CREATE    (1l << 14)
+#define ACC_CLAUSE_DEVICEPTR            (1l << 15)
+#define ACC_CLAUSE_PRIVATE              (1l << 16)
+#define ACC_CLAUSE_FIRSTPRIVATE         (1l << 17)
+#define ACC_CLAUSE_COLLAPSE             (1l << 18)
+#define ACC_CLAUSE_GANG                 (1l << 19)
+#define ACC_CLAUSE_WORKER               (1l << 20)
+#define ACC_CLAUSE_VECTOR               (1l << 21)
+#define ACC_CLAUSE_SEQ                  (1l << 22)
+#define ACC_CLAUSE_INDEPENDENT          (1l << 23)
+#define ACC_CLAUSE_USE_DEVICE           (1l << 24)
+#define ACC_CLAUSE_DEVICE_RESIDENT      (1l << 25)
+#define ACC_CLAUSE_HOST                 (1l << 26)
+#define ACC_CLAUSE_DEVICE               (1l << 27)
+
+/* Match an end of OpenACC directive.  End of OpenACC directive is optional
+   whitespace, followed by '\n' or comment '!'.  */
+
+match
+gfc_match_acc_eos (void)
+{
+  locus old_loc;
+  char c;
+
+  old_loc = gfc_current_locus;
+  gfc_gobble_whitespace ();
+
+  c = gfc_next_ascii_char ();
+  switch (c)
+    {
+    case '!':
+      do
+        c = gfc_next_ascii_char ();
+      while (c != '\n');
+      /* Fall through */
+
+    case '\n':
+      return MATCH_YES;
+    }
+
+  gfc_current_locus = old_loc;
+  return MATCH_NO;
+}
+
+/* Free an acc_clauses structure.  */
+
+void
+gfc_free_acc_clauses (gfc_acc_clauses *c)
+{
+  int i;
+
+  if (c == NULL)
+    return;
+  gfc_free_expr (c->if_expr);
+  gfc_free_expr (c->async_expr);
+  gfc_free_expr (c->gang_expr);
+  gfc_free_expr (c->worker_expr);
+  gfc_free_expr (c->vector_expr);
+  gfc_free_expr (c->num_gangs_expr);
+  gfc_free_expr (c->num_workers_expr);
+  gfc_free_expr (c->vector_length_expr);
+  gfc_free_expr (c->wait_expr);
+
+  for (i = 0; i < ACC_LIST_NUM; i++)
+    gfc_free_namelist (c->lists[i]);
+
+  free (c);
+}
+
+static void
+set_subarray (struct gfc_acc_subarray **acc_subarray,
+              gfc_expr *left, gfc_expr *right, int i)
+{
+  if (*acc_subarray == NULL)
+    *acc_subarray = gfc_get_acc_subarray();
+  (*acc_subarray)->left[i] = left;
+  (*acc_subarray)->right[i] = right;
+}
+
+static match
+match_subarray (struct gfc_acc_subarray **sa)
+{
+  match m;
+
+  m = gfc_match (" ( ");
+  if (m == MATCH_YES)
+    {
+      gfc_expr *left_expr, *right_expr;
+      int i;
+
+      for (i = 0;; i++)
+        {
+          if (i == GFC_MAX_DIMENSIONS)
+            return MATCH_ERROR;
+
+          /* a special case for single array element */
+          if (gfc_match (" %e ) ", &left_expr) == MATCH_YES)
+            {
+              set_subarray (sa, left_expr, left_expr, i);
+              break;
+            }
+          if (gfc_match (" %e : %e ", &left_expr, &right_expr) == MATCH_YES)
+            set_subarray (sa, left_expr, right_expr, i);
+          if (gfc_match (" : %e ", &right_expr) == MATCH_YES)
+            set_subarray (sa, NULL, right_expr, i);
+          if (gfc_match (" %e : ", &left_expr) == MATCH_YES)
+            set_subarray (sa, left_expr, NULL, i);
+
+          if (gfc_match (" , ") == MATCH_YES)
+            continue;
+          else if (gfc_match (" ) ") == MATCH_YES)
+            break;
+          else
+            return MATCH_ERROR;
+        }
+      (*sa)->dimensions = i + 1;
+      return MATCH_YES;
+    }
+  else
+    return m;
+}
+
+/* Match a variable/common block list and construct a namelist from it.  */
+
+static match
+gfc_match_acc_variable_list (const char *str, gfc_namelist **list,
+                             bool allow_common, bool allow_subarrays)
+{
+  gfc_namelist *head, *tail, *p;
+  locus old_loc;
+  char n[GFC_MAX_SYMBOL_LEN+1];
+  gfc_symbol *sym;
+  match m;
+  gfc_symtree *st;
+  struct gfc_acc_subarray *sa = NULL;
+
+  head = tail = NULL;
+
+  old_loc = gfc_current_locus;
+
+  m = gfc_match (str);
+  if (m != MATCH_YES)
+    return m;
+
+  for (;;)
+    {
+      m = gfc_match_symbol (&sym, 1);
+      switch (m)
+        {
+        case MATCH_YES:
+          if (allow_subarrays)
+            {
+              m = match_subarray (&sa);
+              if (m == MATCH_ERROR)
+                goto syntax;
+            }
+          gfc_set_sym_referenced (sym);
+          p = gfc_get_namelist ();
+          if (head == NULL)
+            head = tail = p;
+          else
+            {
+              tail->next = p;
+              tail = tail->next;
+            }
+          tail->sym = sym;
+          if (sa != NULL)
+            tail->acc_subarray = sa;
+          goto next_item;
+        case MATCH_NO:
+          break;
+        case MATCH_ERROR:
+          goto cleanup;
+        }
+
+      if (!allow_common)
+        goto syntax;
+
+      m = gfc_match (" / %n /", n);
+      if (m == MATCH_ERROR)
+        goto cleanup;
+      if (m == MATCH_NO)
+        goto syntax;
+
+      st = gfc_find_symtree (gfc_current_ns->common_root, n);
+      if (st == NULL)
+        {
+          gfc_error ("COMMON block /%s/ not found at %C", n);
+          goto cleanup;
+        }
+      for (sym = st->n.common->head; sym; sym = sym->common_next)
+        {
+          gfc_set_sym_referenced (sym);
+          p = gfc_get_namelist ();
+          if (head == NULL)
+            head = tail = p;
+          else
+            {
+              tail->next = p;
+              tail = tail->next;
+            }
+          tail->sym = sym;
+        }
+
+    next_item:
+      if (gfc_match_char (')') == MATCH_YES)
+        break;
+      if (gfc_match_char (',') != MATCH_YES)
+        goto syntax;
+    }
+
+  while (*list)
+    list = &(*list)->next;
+
+  *list = head;
+  return MATCH_YES;
+
+syntax:
+  gfc_error ("Syntax error in OpenACC variable list at %C");
+
+cleanup:
+  gfc_free_namelist (head);
+  gfc_current_locus = old_loc;
+  return MATCH_ERROR;
+}
+
+/* Match OpenACC directive clauses. MASK is a bitmask of
+   clauses that are allowed for a particular directive.  */
+static match
+gfc_match_acc_clauses(gfc_acc_clauses **cp, long mask)
+{
+  gfc_acc_clauses *c = gfc_get_acc_clauses ();
+  locus old_loc;
+  bool needs_space = true, first = true;
+
+  *cp = NULL;
+  while (1)
+    {
+      if ((first || gfc_match_char (',') != MATCH_YES)
+          && (needs_space && gfc_match_space () != MATCH_YES))
+        break;
+      needs_space = false;
+      first = false;
+      gfc_gobble_whitespace ();
+
+      /* Optional expressions */
+      if ((mask & ACC_CLAUSE_ASYNC) && !c->async)
+        if (gfc_match ("async") == MATCH_YES)
+          {
+            c->async = true;
+            if (gfc_match (" ( %e )", &c->async_expr) == MATCH_YES)
+              needs_space = false;
+            else
+              needs_space = true;
+            continue;
+          }
+      if ((mask & ACC_CLAUSE_GANG) && !c->gang)
+        if (gfc_match ("gang") == MATCH_YES)
+          {
+            c->gang = true;
+            if (gfc_match (" ( %e )", &c->gang_expr) == MATCH_YES)
+              needs_space = false;
+            else
+              needs_space = true;
+            continue;
+          }
+      if ((mask & ACC_CLAUSE_WORKER) && !c->worker)
+        if (gfc_match ("worker") == MATCH_YES)
+          {
+            c->worker = true;
+            if (gfc_match (" ( %e )", &c->worker_expr) == MATCH_YES)
+              needs_space = false;
+            else
+              needs_space = true;
+            continue;
+          }
+      if ((mask & ACC_CLAUSE_VECTOR_LENGTH) && c->vector_length_expr == NULL
+          && gfc_match ("vector_length ( %e )", &c->vector_length_expr) == MATCH_YES)
+        continue;
+      if ((mask & ACC_CLAUSE_VECTOR) && !c->vector)
+        if (gfc_match ("vector") == MATCH_YES)
+          {
+            c->vector = true;
+            if (gfc_match (" ( %e )", &c->vector_expr) == MATCH_YES)
+              needs_space = false;
+            else
+              needs_space = true;
+            continue;
+          }
+
+      /* Expresions */
+      if ((mask & ACC_CLAUSE_IF) && c->if_expr == NULL
+          && gfc_match ("if ( %e )", &c->if_expr) == MATCH_YES)
+        continue;
+      if ((mask & ACC_CLAUSE_NUM_GANGS) && c->num_gangs_expr == NULL
+          && gfc_match ("num_gangs ( %e )", &c->num_gangs_expr) == MATCH_YES)
+        continue;
+      if ((mask & ACC_CLAUSE_NUM_WORKERS) && c->num_workers_expr == NULL
+          && gfc_match ("num_workers ( %e )", &c->num_workers_expr) == MATCH_YES)
+        continue;
+      if ((mask & ACC_CLAUSE_COPY)
+          && gfc_match_acc_variable_list ("copy (",
+                                          &c->lists[ACC_LIST_COPY], true, true)
+             == MATCH_YES)
+        continue;
+      if ((mask & ACC_CLAUSE_COPYIN)
+          && gfc_match_acc_variable_list ("copyin (",
+                                          &c->lists[ACC_LIST_COPYIN], true, true)
+             == MATCH_YES)
+        continue;
+      if ((mask & ACC_CLAUSE_COPYOUT)
+          && gfc_match_acc_variable_list ("copyout (",
+                                          &c->lists[ACC_LIST_COPYOUT], true, true)
+             == MATCH_YES)
+        continue;
+      if ((mask & ACC_CLAUSE_CREATE)
+          && gfc_match_acc_variable_list ("create (",
+                                          &c->lists[ACC_LIST_CREATE], true, true)
+             == MATCH_YES)
+        continue;
+      if ((mask & ACC_CLAUSE_PRESENT)
+          && gfc_match_acc_variable_list ("present (",
+                                          &c->lists[ACC_LIST_PRESENT], true, true)
+             == MATCH_YES)
+        continue;
+      if ((mask & ACC_CLAUSE_PRESENT_OR_COPY)
+          && gfc_match_acc_variable_list ("present_or_copy (",
+                                          &c->lists[ACC_LIST_PRESENT_OR_COPY],
+                                          true, true)
+             == MATCH_YES)
+        continue;
+      if ((mask & ACC_CLAUSE_PRESENT_OR_COPY)
+          && gfc_match_acc_variable_list ("pcopy (",
+                                          &c->lists[ACC_LIST_PRESENT_OR_COPY],
+                                          true, true)
+             == MATCH_YES)
+        continue;
+      if ((mask & ACC_CLAUSE_PRESENT_OR_COPYIN)
+          && gfc_match_acc_variable_list ("present_or_copyin (",
+                                          &c->lists[ACC_LIST_PRESENT_OR_COPYIN],
+                                          true, true)
+             == MATCH_YES)
+        continue;
+      if ((mask & ACC_CLAUSE_PRESENT_OR_COPYIN)
+          && gfc_match_acc_variable_list ("pcopyin (",
+                                          &c->lists[ACC_LIST_PRESENT_OR_COPYIN],
+                                          true, true)
+             == MATCH_YES)
+        continue;
+      if ((mask & ACC_CLAUSE_PRESENT_OR_COPYOUT)
+          && gfc_match_acc_variable_list ("present_or_copyout (",
+                                          &c->lists[ACC_LIST_PRESENT_OR_COPYOUT],
+                                          true, true)
+             == MATCH_YES)
+        continue;
+      if ((mask & ACC_CLAUSE_PRESENT_OR_COPYOUT)
+          && gfc_match_acc_variable_list ("pcopyout (",
+                                          &c->lists[ACC_LIST_PRESENT_OR_COPYOUT],
+                                          true, true)
+             == MATCH_YES)
+        continue;
+      if ((mask & ACC_CLAUSE_PRESENT_OR_CREATE)
+          && gfc_match_acc_variable_list ("present_or_create (",
+                                          &c->lists[ACC_LIST_PRESENT_OR_CREATE],
+                                          true, true)
+             == MATCH_YES)
+        continue;
+      if ((mask & ACC_CLAUSE_PRESENT_OR_CREATE)
+          && gfc_match_acc_variable_list ("pcreate (",
+                                          &c->lists[ACC_LIST_PRESENT_OR_CREATE],
+                                          true, true)
+             == MATCH_YES)
+        continue;
+      if ((mask & ACC_CLAUSE_DEVICEPTR)
+          && gfc_match_acc_variable_list ("deviceptr (",
+                                          &c->lists[ACC_LIST_DEVICEPTR], true, false)
+             == MATCH_YES)
+        continue;
+      if ((mask & ACC_CLAUSE_PRIVATE)
+          && gfc_match_acc_variable_list ("private (",
+                                          &c->lists[ACC_LIST_PRIVATE], true, false)
+             == MATCH_YES)
+        continue;
+      if ((mask & ACC_CLAUSE_FIRSTPRIVATE)
+          && gfc_match_acc_variable_list ("firstprivate (",
+                                          &c->lists[ACC_LIST_FIRSTPRIVATE], true, false)
+             == MATCH_YES)
+        continue;
+      if ((mask & ACC_CLAUSE_USE_DEVICE)
+          && gfc_match_acc_variable_list ("use_device (",
+                                          &c->lists[ACC_LIST_USE_DEVICE], true, false)
+             == MATCH_YES)
+        continue;
+      if ((mask & ACC_CLAUSE_DEVICE_RESIDENT)
+          && gfc_match_acc_variable_list ("device_resident (",
+                                          &c->lists[ACC_LIST_DEVICE_RESIDENT], true, false)
+             == MATCH_YES)
+        continue;
+      if ((mask & ACC_CLAUSE_HOST)
+          && gfc_match_acc_variable_list ("host (",
+                                          &c->lists[ACC_LIST_HOST], true, false)
+             == MATCH_YES)
+        continue;
+      if ((mask & ACC_CLAUSE_DEVICE)
+          && gfc_match_acc_variable_list ("device (",
+                                          &c->lists[ACC_LIST_DEVICE], true, false)
+             == MATCH_YES)
+        continue;
+
+
+      /* Integer */
+      if ((mask & ACC_CLAUSE_COLLAPSE) && !c->collapse)
+        {
+          gfc_expr *cexpr = NULL;
+          match m = gfc_match ("collapse ( %e )", &cexpr);
+
+          if (m == MATCH_YES)
+            {
+              int collapse;
+              const char *p = gfc_extract_int (cexpr, &collapse);
+              if (p)
+                {
+                  gfc_error_now (p);
+                  collapse = 1;
+                }
+              else if (collapse <= 0)
+                {
+                  gfc_error_now ("COLLAPSE clause argument not"
+                                 " constant positive integer at %C");
+                  collapse = 1;
+                }
+              c->collapse = collapse;
+              gfc_free_expr (cexpr);
+              continue;
+            }
+        }
+
+      /* Without params */
+      if ((mask & ACC_CLAUSE_SEQ) && !c->seq
+          && gfc_match ("seq") == MATCH_YES)
+        {
+          c->seq = needs_space = true;
+          continue;
+        }
+      if ((mask & ACC_CLAUSE_INDEPENDENT) && !c->independent
+          && gfc_match ("independent") == MATCH_YES)
+        {
+          c->independent = needs_space = true;
+          continue;
+        }
+
+      /* Reduction */
+      old_loc = gfc_current_locus;
+      if ((mask & ACC_CLAUSE_REDUCTION)
+          && gfc_match ("reduction (") == MATCH_YES)
+        {
+          int reduction = ACC_LIST_NUM;
+          char buffer[GFC_MAX_SYMBOL_LEN + 1];
+          if (gfc_match_char ('+') == MATCH_YES)
+            reduction = ACC_LIST_PLUS;
+          else if (gfc_match_char ('*') == MATCH_YES)
+            reduction = ACC_LIST_MULT;
+          else if (gfc_match_char ('-') == MATCH_YES)
+            reduction = ACC_LIST_SUB;
+          else if (gfc_match (".and.") == MATCH_YES)
+            reduction = ACC_LIST_AND;
+          else if (gfc_match (".or.") == MATCH_YES)
+            reduction = ACC_LIST_OR;
+          else if (gfc_match (".eqv.") == MATCH_YES)
+            reduction = ACC_LIST_EQV;
+          else if (gfc_match (".neqv.") == MATCH_YES)
+            reduction = ACC_LIST_NEQV;
+          else if (gfc_match_name (buffer) == MATCH_YES)
+            {
+              gfc_symbol *sym;
+              const char *n = buffer;
+
+              gfc_find_symbol (buffer, NULL, 1, &sym);
+              if (sym != NULL)
+                {
+                  if (sym->attr.intrinsic)
+                    n = sym->name;
+                  else if ((sym->attr.flavor != FL_UNKNOWN
+                            && sym->attr.flavor != FL_PROCEDURE)
+                           || sym->attr.external
+                           || sym->attr.generic
+                           || sym->attr.entry
+                           || sym->attr.result
+                           || sym->attr.dummy
+                           || sym->attr.subroutine
+                           || sym->attr.pointer
+                           || sym->attr.target
+                           || sym->attr.cray_pointer
+                           || sym->attr.cray_pointee
+                           || (sym->attr.proc != PROC_UNKNOWN
+                               && sym->attr.proc != PROC_INTRINSIC)
+                           || sym->attr.if_source != IFSRC_UNKNOWN
+                           || sym == sym->ns->proc_name)
+                    {
+                      gfc_error_now ("%s is not INTRINSIC procedure name "
+                                     "at %C", buffer);
+                      sym = NULL;
+                    }
+                  else
+                    n = sym->name;
+                }
+              if (strcmp (n, "max") == 0)
+                reduction = ACC_LIST_MAX;
+              else if (strcmp (n, "min") == 0)
+                reduction = ACC_LIST_MIN;
+              else if (strcmp (n, "iand") == 0)
+                reduction = ACC_LIST_IAND;
+              else if (strcmp (n, "ior") == 0)
+                reduction = ACC_LIST_IOR;
+              else if (strcmp (n, "ieor") == 0)
+                reduction = ACC_LIST_IEOR;
+              if (reduction != ACC_LIST_NUM
+                  && sym != NULL
+                  && ! sym->attr.intrinsic
+                  && ! sym->attr.use_assoc
+                  && ((sym->attr.flavor == FL_UNKNOWN
+                       && !gfc_add_flavor (&sym->attr, FL_PROCEDURE, sym->name, NULL))
+                      || !gfc_add_intrinsic (&sym->attr, NULL)))
+                {
+                  gfc_free_acc_clauses (c);
+                  return MATCH_ERROR;
+                }
+            }
+          if (reduction != ACC_LIST_NUM
+              && gfc_match_acc_variable_list (" :", &c->lists[reduction],
+                                              false, false)
+                 == MATCH_YES)
+            continue;
+          else
+            gfc_current_locus = old_loc;
+        }
+
+      break;
+    }
+
+  if (gfc_match_acc_eos () != MATCH_YES)
+    {
+      gfc_free_acc_clauses (c);
+      return MATCH_ERROR;
+    }
+
+  *cp = c;
+  return MATCH_YES;
+}
+
+#define ACC_PARALLEL_CLAUSES \
+  (ACC_CLAUSE_IF | ACC_CLAUSE_ASYNC | ACC_CLAUSE_NUM_GANGS                                       \
+   | ACC_CLAUSE_NUM_WORKERS | ACC_CLAUSE_VECTOR_LENGTH | ACC_CLAUSE_REDUCTION                    \
+   | ACC_CLAUSE_COPY | ACC_CLAUSE_COPYIN | ACC_CLAUSE_COPYOUT                                    \
+   | ACC_CLAUSE_CREATE | ACC_CLAUSE_PRESENT | ACC_CLAUSE_PRESENT_OR_COPY                         \
+   | ACC_CLAUSE_PRESENT_OR_COPYIN | ACC_CLAUSE_PRESENT_OR_COPYOUT | ACC_CLAUSE_PRESENT_OR_CREATE \
+   | ACC_CLAUSE_DEVICEPTR | ACC_CLAUSE_PRIVATE | ACC_CLAUSE_FIRSTPRIVATE)
+
+#define ACC_KERNELS_CLAUSES \
+  (ACC_CLAUSE_IF | ACC_CLAUSE_ASYNC | ACC_CLAUSE_DEVICEPTR                                       \
+   | ACC_CLAUSE_COPY | ACC_CLAUSE_COPYIN | ACC_CLAUSE_COPYOUT                                    \
+   | ACC_CLAUSE_CREATE | ACC_CLAUSE_PRESENT | ACC_CLAUSE_PRESENT_OR_COPY                         \
+   | ACC_CLAUSE_PRESENT_OR_COPYIN | ACC_CLAUSE_PRESENT_OR_COPYOUT | ACC_CLAUSE_PRESENT_OR_CREATE)
+
+#define ACC_DATA_CLAUSES \
+  (ACC_CLAUSE_IF | ACC_CLAUSE_DEVICEPTR                                                          \
+   | ACC_CLAUSE_COPY | ACC_CLAUSE_COPYIN | ACC_CLAUSE_COPYOUT                                    \
+   | ACC_CLAUSE_CREATE | ACC_CLAUSE_PRESENT | ACC_CLAUSE_PRESENT_OR_COPY                         \
+   | ACC_CLAUSE_PRESENT_OR_COPYIN | ACC_CLAUSE_PRESENT_OR_COPYOUT | ACC_CLAUSE_PRESENT_OR_CREATE)
+
+#define ACC_LOOP_CLAUSES \
+  (ACC_CLAUSE_COLLAPSE | ACC_CLAUSE_GANG | ACC_CLAUSE_WORKER | ACC_CLAUSE_VECTOR \
+   | ACC_CLAUSE_SEQ | ACC_CLAUSE_INDEPENDENT | ACC_CLAUSE_PRIVATE | ACC_CLAUSE_REDUCTION)
+
+#define ACC_PARALLEL_LOOP_CLAUSES \
+  (ACC_LOOP_CLAUSES | ACC_PARALLEL_CLAUSES)
+
+#define ACC_KERNELS_LOOP_CLAUSES \
+  (ACC_LOOP_CLAUSES | ACC_KERNELS_CLAUSES)
+
+#define ACC_HOST_DATA_CLAUSES ACC_CLAUSE_USE_DEVICE
+
+#define ACC_DECLARE_CLAUSES \
+  (ACC_CLAUSE_COPY | ACC_CLAUSE_COPYIN | ACC_CLAUSE_COPYOUT | ACC_CLAUSE_CREATE \
+   | ACC_CLAUSE_DEVICEPTR | ACC_CLAUSE_DEVICE_RESIDENT | ACC_CLAUSE_PRESENT | ACC_CLAUSE_PRESENT_OR_COPY \
+   | ACC_CLAUSE_PRESENT_OR_COPYIN | ACC_CLAUSE_PRESENT_OR_COPYOUT | ACC_CLAUSE_PRESENT_OR_CREATE)
+
+#define ACC_UPDATE_CLAUSES \
+  (ACC_CLAUSE_IF | ACC_CLAUSE_ASYNC | ACC_CLAUSE_HOST | ACC_CLAUSE_DEVICE)
+
+match
+gfc_match_acc_parallel_loop (void)
+{
+  gfc_acc_clauses *c;
+  if (gfc_match_acc_clauses (&c, ACC_PARALLEL_LOOP_CLAUSES) != MATCH_YES)
+    return MATCH_ERROR;
+
+  new_st.op = EXEC_ACC_PARALLEL_LOOP;
+  new_st.ext.acc_clauses = c;
+  return MATCH_YES;
+}
+
+match
+gfc_match_acc_parallel (void)
+{
+  gfc_acc_clauses *c;
+  if (gfc_match_acc_clauses (&c, ACC_PARALLEL_CLAUSES) != MATCH_YES)
+    return MATCH_ERROR;
+
+  new_st.op = EXEC_ACC_PARALLEL;
+  new_st.ext.acc_clauses = c;
+  return MATCH_YES;
+}
+
+match
+gfc_match_acc_kernels_loop (void)
+{
+  gfc_acc_clauses *c;
+  if (gfc_match_acc_clauses (&c, ACC_KERNELS_LOOP_CLAUSES) != MATCH_YES)
+    return MATCH_ERROR;
+
+  new_st.op = EXEC_ACC_KERNELS_LOOP;
+  new_st.ext.acc_clauses = c;
+  return MATCH_YES;
+}
+
+match
+gfc_match_acc_kernels (void)
+{
+  gfc_acc_clauses *c;
+  if (gfc_match_acc_clauses (&c, ACC_KERNELS_CLAUSES) != MATCH_YES)
+    return MATCH_ERROR;
+
+  new_st.op = EXEC_ACC_KERNELS;
+  new_st.ext.acc_clauses = c;
+  return MATCH_YES;
+}
+
+match
+gfc_match_acc_data (void)
+{
+  gfc_acc_clauses *c;
+  if (gfc_match_acc_clauses (&c, ACC_DATA_CLAUSES) != MATCH_YES)
+    return MATCH_ERROR;
+
+  new_st.op = EXEC_ACC_DATA;
+  new_st.ext.acc_clauses = c;
+  return MATCH_YES;
+}
+
+match
+gfc_match_acc_host_data (void)
+{
+  gfc_acc_clauses *c;
+  if (gfc_match_acc_clauses (&c, ACC_HOST_DATA_CLAUSES) != MATCH_YES)
+    return MATCH_ERROR;
+
+  new_st.op = EXEC_ACC_HOST_DATA;
+  new_st.ext.acc_clauses = c;
+  return MATCH_YES;
+}
+
+match
+gfc_match_acc_loop (void)
+{
+  gfc_acc_clauses *c;
+  if (gfc_match_acc_clauses (&c, ACC_LOOP_CLAUSES) != MATCH_YES)
+    return MATCH_ERROR;
+
+  new_st.op = EXEC_ACC_LOOP;
+  new_st.ext.acc_clauses = c;
+  return MATCH_YES;
+}
+
+match
+gfc_match_acc_declare (void)
+{
+  gfc_acc_clauses *c;
+  if (gfc_match_acc_clauses (&c, ACC_DECLARE_CLAUSES) != MATCH_YES)
+    return MATCH_ERROR;
+
+  new_st.ext.acc_clauses = c;
+  return MATCH_YES;
+}
+
+match
+gfc_match_acc_update (void)
+{
+  gfc_acc_clauses *c;
+  if (gfc_match_acc_clauses (&c, ACC_UPDATE_CLAUSES) != MATCH_YES)
+    return MATCH_ERROR;
+
+  new_st.op = EXEC_ACC_UPDATE;
+  new_st.ext.acc_clauses = c;
+  return MATCH_YES;
+}
+
+match
+gfc_match_acc_wait (void)
+{
+  gfc_acc_clauses *c = gfc_get_acc_clauses ();
+  gfc_match (" ( %e )", &c->wait_expr);
+
+  new_st.op = EXEC_ACC_WAIT;
+  new_st.ext.acc_clauses = c;
+  return MATCH_YES;
+}
+
+match
+gfc_match_acc_cache (void)
+{
+  gfc_acc_clauses *c = gfc_get_acc_clauses ();
+  match m = gfc_match_acc_variable_list (" (",&c->lists[ACC_LIST_CACHE], true, true);
+  if (m != MATCH_YES)
+    {
+      gfc_free_acc_clauses(c);
+      return m;
+    }
+
+  if (gfc_current_state() != COMP_DO)
+    {
+      gfc_error ("ACC CACHE directive must be inside of loop %C");
+      gfc_free_acc_clauses(c);
+      return MATCH_ERROR;
+    }
+
+  new_st.op = EXEC_ACC_CACHE;
+  new_st.ext.acc_clauses = c;
+  return MATCH_YES;
+}
+
+struct acc_context
+{
+  gfc_code *code;
+  struct acc_context *previous;
+} *acc_current_ctx;
+
+static void
+add_var_to_pcopy_clause (gfc_symbol *sym, gfc_code **acc, locus loc)
+{
+  gfc_namelist *tail, *nl;
+  struct acc_context *ctx;
+  int i;
+
+  for (i = ACC_LIST_DATA_CLAUSE_FIRST; i <= ACC_LIST_DATA_CLAUSE_LAST; i++)
+    for (nl = (*acc)->ext.acc_clauses->lists[i]; nl; nl = nl->next)
+      if (nl->sym == sym)
+        return;
+
+  for (ctx = acc_current_ctx; ctx; ctx = ctx->previous)
+    if (ctx->code->op == EXEC_ACC_DATA)
+      for (i = ACC_LIST_DATA_CLAUSE_FIRST; i <= ACC_LIST_DATA_CLAUSE_LAST; i++)
+        for (nl = ctx->code->ext.acc_clauses->lists[i]; nl; nl = nl->next)
+          if (nl->sym == sym)
+            return;
+
+  gfc_warning ("Inserting present_or_copy(%s) clause to ACC region %L", sym->name, &loc);
+
+  tail = gfc_get_namelist ();
+  tail->sym = sym;
+
+  nl = (*acc)->ext.acc_clauses->lists[ACC_LIST_PRESENT_OR_COPY];
+  if (nl == NULL)
+    (*acc)->ext.acc_clauses->lists[ACC_LIST_PRESENT_OR_COPY] = tail;
+  else
+    {
+      /* Jump to the tail of the namelist. */
+      for (; nl->next; nl = nl->next)
+        {}
+      nl->next = tail;
+    }
+}
+
+static void
+add_pcopy_clause (gfc_code *code, gfc_code **acc)
+{
+  if (code == NULL)
+    return;
+  if (code->block)
+    add_pcopy_clause (code->block->next, acc);
+
+  if (code->expr1 && code->expr1->expr_type == EXPR_VARIABLE)
+    add_var_to_pcopy_clause (code->expr1->symtree->n.sym, acc, code->loc);
+  if (code->expr2 && code->expr2->expr_type == EXPR_VARIABLE)
+    add_var_to_pcopy_clause (code->expr2->symtree->n.sym, acc, code->loc);
+  if (code->expr3 && code->expr3->expr_type == EXPR_VARIABLE)
+    add_var_to_pcopy_clause (code->expr3->symtree->n.sym, acc, code->loc);
+  if (code->expr4 && code->expr4->expr_type == EXPR_VARIABLE)
+    add_var_to_pcopy_clause (code->expr4->symtree->n.sym, acc, code->loc);
+
+  if (code->next)
+    add_pcopy_clause (code->next, acc);
+}
+
+void
+gfc_resolve_acc_blocks (gfc_code *code, gfc_namespace *ns)
+{
+  struct acc_context ctx;
+
+  /* kernels or parallel regions may not contain other parallel or kernels regions */
+  if (code->op == EXEC_ACC_PARALLEL || code->op == EXEC_ACC_PARALLEL_LOOP ||
+      code->op == EXEC_ACC_KERNELS || code->op == EXEC_ACC_KERNELS_LOOP)
+    {
+      struct acc_context* c;
+      for (c = acc_current_ctx; c; c = c->previous)
+        if (c->code->op == EXEC_ACC_PARALLEL || c->code->op == EXEC_ACC_PARALLEL_LOOP
+            || c->code->op == EXEC_ACC_KERNELS || c->code->op == EXEC_ACC_KERNELS_LOOP)
+          {
+            const char *name;
+            if (c->code->op == EXEC_ACC_PARALLEL || c->code->op == EXEC_ACC_PARALLEL_LOOP)
+              name = "PARALLEL";
+            else
+              name = "KERNELS";
+            gfc_error ("%s construct may not contain parallel or kernels regions %L",
+                     name, &code->loc);
+          }
+    }
+
+  ctx.code = code;
+  ctx.previous = acc_current_ctx;
+  acc_current_ctx = &ctx;
+
+  gfc_resolve_blocks (code->block, ns);
+
+  /* Now we should add present_or_copy clause. */
+  if (code->op == EXEC_ACC_KERNELS ||
+      code->op == EXEC_ACC_PARALLEL ||
+      code->op == EXEC_ACC_KERNELS_LOOP ||
+      code->op == EXEC_ACC_PARALLEL_LOOP)
+    add_pcopy_clause (code->block->next, &code);
+
+  acc_current_ctx = ctx.previous;
+}
+
+static void
+resolve_acc_scalar_int_expr (gfc_expr *expr, const char *clause)
+{
+  if (!gfc_resolve_expr (expr)
+      || expr->ts.type != BT_INTEGER || expr->rank != 0)
+    gfc_error ("%s clause at %L requires a scalar INTEGER expression",
+                     clause, &expr->where);
+  if (expr->expr_type == EXPR_CONSTANT && expr->ts.type == BT_INTEGER
+      && expr->value.integer->_mp_size <= 0)
+    gfc_warning ("INTEGER expression of %s clause at %L must be positive",
+                     clause, &expr->where);
+}
+
+static void
+resolve_subarray (gfc_namelist *n, locus *where)
+{
+  struct gfc_acc_subarray *sa = n->acc_subarray;
+  gfc_symbol *sym = n->sym;
+  int i;
+
+  if (sym->as->rank <= 0)
+    gfc_error ("subarray of variable %L", where);
+  if (sym->as->rank != sa->dimensions)
+    gfc_error ("Number of dimensions of array not equal to rank %L", where);
+  for (i = 0; i < sa->dimensions; i++)
+    {
+      if (i < sa->dimensions - 1)
+        if (sa->left[i] == NULL || sa->right[i] == NULL)
+          gfc_warning ("All dimensions of subarray except last must specify whole dimension %L", where);
+
+      if (sa->left[i] == NULL)
+        sa->left[i] = gfc_copy_expr (sym->as->lower[i]);
+      if (sa->right[i] == NULL)
+        sa->right[i] = gfc_copy_expr (sym->as->upper[i]);
+
+      if (!gfc_resolve_expr(sa->left[i])
+          || sa->left[i]->ts.type != BT_INTEGER || sa->left[i]->rank != 0
+          || !gfc_resolve_expr(sa->right[i])
+          || sa->right[i]->ts.type != BT_INTEGER || sa->right[i]->rank != 0)
+        gfc_error ("Bound must be a scalar INTEGER expression %L", where);
+    }
+}
+
+static void
+resolve_acc_clauses (gfc_code *code)
+{
+  gfc_acc_clauses *acc_clauses = code->ext.acc_clauses;
+  gfc_namelist *n;
+  int list;
+  static const char *clause_names[]
+    = { "COPY", "COPYIN", "COPYOUT", "CREATE", "PRESENT",
+        "PRESENT_OR_COPY", "PRESENT_OR_COPYIN", "PRESENT_OR_COPYOUT", "PRESENT_OR_CREATE", "DEVICEPTR",
+        "PRIVATE", "FIRSTPRIVATE", "USE_DEVICE", "DEVICE_RESIDENT", "HOST",
+        "DEVICE", "CACHE", "REDUCTION"};
+
+  if (acc_clauses == NULL)
+    return;
+
+  /* Expressions */
+  if (acc_clauses->if_expr)
+    {
+      gfc_expr *expr = acc_clauses->if_expr;
+      if (!gfc_resolve_expr (expr)
+          || expr->ts.type != BT_LOGICAL || expr->rank != 0)
+        gfc_error ("IF clause at %L requires a scalar LOGICAL expression",
+                           &expr->where);
+    }
+  if (acc_clauses->async)
+    if (acc_clauses->async_expr)
+      resolve_acc_scalar_int_expr (acc_clauses->async_expr, "ASYNC");
+  if (acc_clauses->num_gangs_expr)
+    resolve_acc_scalar_int_expr (acc_clauses->num_gangs_expr, "NUM_GANGS");
+  if (acc_clauses->num_workers_expr)
+    resolve_acc_scalar_int_expr (acc_clauses->num_workers_expr, "NUM_WORKERS");
+  if (acc_clauses->vector_length_expr)
+    resolve_acc_scalar_int_expr (acc_clauses->vector_length_expr, "VECTOR_LENGTH");
+  if (acc_clauses->gang_expr)
+    resolve_acc_scalar_int_expr (acc_clauses->gang_expr, "GANG");
+  if (acc_clauses->worker_expr)
+    resolve_acc_scalar_int_expr (acc_clauses->worker_expr, "WORKER");
+  if (acc_clauses->vector_expr)
+    resolve_acc_scalar_int_expr (acc_clauses->vector_expr, "VECTOR");
+
+  if (acc_clauses->seq && acc_clauses->independent)
+    gfc_error ("Both SEQ and INDEPENDENT clauses are not allowed at %L",
+               &code->loc);
+
+  for (list = 0; list < ACC_LIST_NUM; list++)
+    for (n = acc_clauses->lists[list]; n; n = n->next)
+      {
+        n->sym->mark = 0;
+        if (n->sym->attr.flavor == FL_VARIABLE)
+          continue;
+        if (n->sym->attr.flavor == FL_PROCEDURE
+            && n->sym->result == n->sym
+            && n->sym->attr.function)
+          {
+            if (gfc_current_ns->proc_name == n->sym
+                || (gfc_current_ns->parent
+                    && gfc_current_ns->parent->proc_name == n->sym))
+              continue;
+            if (gfc_current_ns->proc_name->attr.entry_master)
+              {
+                gfc_entry_list *el = gfc_current_ns->entries;
+                for (; el; el = el->next)
+                  if (el->sym == n->sym)
+                    break;
+                if (el)
+                  continue;
+              }
+            if (gfc_current_ns->parent
+                && gfc_current_ns->parent->proc_name->attr.entry_master)
+              {
+                gfc_entry_list *el = gfc_current_ns->parent->entries;
+                for (; el; el = el->next)
+                  if (el->sym == n->sym)
+                    break;
+                if (el)
+                  continue;
+              }
+            if (n->sym->attr.proc_pointer)
+              continue;
+          }
+        gfc_error ("Object '%s' is not a variable at %L", n->sym->name,
+                   &code->loc);
+      }
+
+  // todo:
+  /* Check the variable does not present in multiple clauses.
+     However, following combinations of clauses are allowed
+     1) copyin & copyout
+     2) present_or_copyin & copyout
+     Consequently, we need to drop these clauses to check them later
+   */
+  for (list = 0; list < ACC_LIST_NUM; list++)
+    for (n = acc_clauses->lists[list]; n; n = n->next)
+      {
+        if (n->sym->mark)
+          gfc_warning ("Symbol '%s' present on multiple clauses at %L",
+              n->sym->name, &code->loc);
+        else
+          n->sym->mark = 1;
+      }
+  /* Lists */
+  for (list = 0; list < ACC_LIST_NUM; list++)
+    if ((n = acc_clauses->lists[list]) != NULL)
+      {
+        const char *name;
+
+        if (list < ACC_LIST_REDUCTION_FIRST)
+          name = clause_names[list];
+        else if (list <= ACC_LIST_REDUCTION_LAST)
+          name = clause_names[ACC_LIST_REDUCTION_FIRST];
+        else
+          gcc_unreachable ();
+
+        if (n->acc_subarray)
+          resolve_subarray (n, &code->loc);
+
+        if (list > ACC_LIST_DATA_CLAUSE_LAST)
+          {
+            if (n->sym->attr.pointer)
+              gfc_error ("POINTER object '%s' in %s clause at %L",
+                         n->sym->name, name, &code->loc);
+            if (n->sym->as && n->sym->as->type == AS_ASSUMED_SIZE)
+              gfc_error ("Assumed size array '%s' in %s clause at %L",
+                         n->sym->name, name, &code->loc);
+          }
+
+        if (list == ACC_LIST_DEVICEPTR)
+          {
+            if (n->sym->attr.pointer)
+              gfc_error ("POINTER object '%s' in %s clause at %L",
+                         n->sym->name, name, &code->loc);
+            if (n->sym->attr.allocatable)
+              gfc_error ("ALLOCATABLE object '%s' in %s clause at %L",
+                         n->sym->name, name, &code->loc);
+            if (n->sym->attr.value)
+              gfc_error ("VALUE object '%s' in %s clause at %L",
+                         n->sym->name, name, &code->loc);
+          }
+
+        if (list >= ACC_LIST_DATA_CLAUSE_FIRST
+            && list <= ACC_LIST_DATA_CLAUSE_LAST)
+          {
+            if (n->sym->ts.type == BT_DERIVED
+                && n->sym->attr.allocatable)
+              gfc_error ("ALLOCATABLE object '%s' of DERIVED type in %s clause at %L",
+                         n->sym->name, name, &code->loc);
+            if (n->sym->ts.type == BT_DERIVED
+                && n->sym->attr.pointer)
+              gfc_error ("POINTER object '%s' of DERIVED type in %s clause at %L",
+                         n->sym->name, name, &code->loc);
+          }
+
+        switch (list)
+          {
+          case ACC_LIST_PLUS:
+          case ACC_LIST_MULT:
+          case ACC_LIST_SUB:
+            if (!gfc_numeric_ts (&n->sym->ts))
+              gfc_error ("%c REDUCTION variable '%s' at %L must be of numeric type, got %s",
+                         list == ACC_LIST_PLUS ? '+'
+                         : list == ACC_LIST_MULT ? '*' : '-',
+                         n->sym->name, &code->loc,
+                         gfc_typename (&n->sym->ts));
+            break;
+          case ACC_LIST_AND:
+          case ACC_LIST_OR:
+          case ACC_LIST_EQV:
+          case ACC_LIST_NEQV:
+            if (n->sym->ts.type != BT_LOGICAL)
+              gfc_error ("%s REDUCTION variable '%s' must be LOGICAL "
+                         "at %L",
+                         list == ACC_LIST_AND ? ".AND."
+                         : list == ACC_LIST_OR ? ".OR."
+                         : list == ACC_LIST_EQV ? ".EQV." : ".NEQV.",
+                         n->sym->name, &code->loc);
+            break;
+          case ACC_LIST_MAX:
+          case ACC_LIST_MIN:
+            if (n->sym->ts.type != BT_INTEGER
+                && n->sym->ts.type != BT_REAL)
+              gfc_error ("%s REDUCTION variable '%s' must be "
+                         "INTEGER or REAL at %L",
+                         list == ACC_LIST_MAX ? "MAX" : "MIN",
+                         n->sym->name, &code->loc);
+            break;
+          case ACC_LIST_IAND:
+          case ACC_LIST_IOR:
+          case ACC_LIST_IEOR:
+            if (n->sym->ts.type != BT_INTEGER)
+              gfc_error ("%s REDUCTION variable '%s' must be INTEGER "
+                         "at %L",
+                         list == ACC_LIST_IAND ? "IAND"
+                         : list == ACC_LIST_MULT ? "IOR" : "IEOR",
+                         n->sym->name, &code->loc);
+            break;
+          }
+      }
+}
+
+static void
+resolve_acc_loop(gfc_code *code)
+{
+  gfc_code *do_code, *c;
+  int i, collapse;
+  gfc_symbol *dovar;
+  int list;
+
+  if (code->ext.acc_clauses)
+    resolve_acc_clauses (code);
+
+  for (list = ACC_LIST_REDUCTION_FIRST; list <= ACC_LIST_REDUCTION_LAST; list++)
+    if (code->ext.acc_clauses->lists[list])
+      {
+        bool kernels_region = false;
+        struct acc_context *c;
+
+        if (code->op == EXEC_ACC_KERNELS_LOOP)
+          kernels_region = true;
+        if (!kernels_region)
+          for (c = acc_current_ctx; c != NULL && !kernels_region; c = c->previous)
+            if (c->code->op == EXEC_ACC_KERNELS)
+              kernels_region = true;
+
+        if (kernels_region)
+          {
+            gfc_error ("REDUCTION clause is not allowed in KERNELS region at %L",
+                &code->loc);
+            break;
+          }
+      }
+
+  do_code = code->block->next;
+  collapse = code->ext.acc_clauses->collapse;
+
+  if (collapse <= 0)
+    collapse = 1;
+  for (i = 1; i <= collapse; i++)
+    {
+      if (do_code->op == EXEC_DO_WHILE)
+        {
+          gfc_error ("!$ACC LOOP cannot be a DO WHILE or DO without loop control "
+                     "at %L", &do_code->loc);
+          break;
+        }
+      gcc_assert (do_code->op == EXEC_DO);
+      if (do_code->ext.iterator->var->ts.type != BT_INTEGER)
+        gfc_error ("!$ACC LOOP iteration variable must be of type integer at %L",
+                   &do_code->loc);
+      dovar = do_code->ext.iterator->var->symtree->n.sym;
+      if (i > 1)
+        {
+          gfc_code *do_code2 = code->block->next;
+          int j;
+
+          for (j = 1; j < i; j++)
+            {
+              gfc_symbol *ivar = do_code2->ext.iterator->var->symtree->n.sym;
+              if (dovar == ivar
+                  || gfc_find_sym_in_expr (ivar, do_code->ext.iterator->start)
+                  || gfc_find_sym_in_expr (ivar, do_code->ext.iterator->end)
+                  || gfc_find_sym_in_expr (ivar, do_code->ext.iterator->step))
+                {
+                  gfc_error ("!$ACC LOOP collapsed loops don't form rectangular iteration space at %L",
+                             &do_code->loc);
+                  break;
+                }
+              if (j < i)
+                break;
+              do_code2 = do_code2->block->next;
+            }
+        }
+      if (i == collapse)
+        break;
+      for (c = do_code->next; c; c = c->next)
+        if (c->op != EXEC_NOP && c->op != EXEC_CONTINUE)
+          {
+            gfc_error ("collapsed !$ACC LOOP loops not perfectly nested at %L",
+                       &c->loc);
+            break;
+          }
+      if (c)
+        break;
+      do_code = do_code->block;
+      if (do_code->op != EXEC_DO && do_code->op != EXEC_DO_WHILE)
+        {
+          gfc_error ("not enough DO loops for collapsed !$ACC LOOP at %L",
+                     &code->loc);
+          break;
+        }
+      do_code = do_code->next;
+      if (do_code == NULL
+          || (do_code->op != EXEC_DO && do_code->op != EXEC_DO_WHILE))
+        {
+          gfc_error ("not enough DO loops for collapsed !$ACC LOOP at %L",
+                     &code->loc);
+          break;
+        }
+    }
+}
+
+static void
+resolve_acc_cache (gfc_code *code)
+{
+  gfc_namelist* n;
+
+  for (n = code->ext.acc_clauses->lists[ACC_LIST_CACHE]; n; n = n->next)
+    if (!n->acc_subarray)
+      gfc_error ("Only single array elements and subarrays are allowed in ACC CACHE directive %L",
+                 &code->loc);
+}
+
+/* Resolve OpenACC directive clauses and check various requirements
+   of each directive.  */
+
+void
+gfc_resolve_acc_directive (gfc_code *code, gfc_namespace *ns ATTRIBUTE_UNUSED)
+{
+  switch (code->op)
+    {
+    case EXEC_ACC_CACHE:
+      resolve_acc_cache (code);
+      break;
+    case EXEC_ACC_WAIT:
+      break;
+    case EXEC_ACC_UPDATE:
+    case EXEC_ACC_HOST_DATA:
+    case EXEC_ACC_DATA:
+    case EXEC_ACC_KERNELS:
+    case EXEC_ACC_PARALLEL:
+      resolve_acc_clauses (code);
+      break;
+    case EXEC_ACC_LOOP:
+    case EXEC_ACC_KERNELS_LOOP:
+    case EXEC_ACC_PARALLEL_LOOP:
+      resolve_acc_loop (code);
+      break;
+    default:
+      break;
+    }
+}
diff --git a/gcc/fortran/options.c b/gcc/fortran/options.c
index 3a9c508dc27..b512ae6a104 100644
--- a/gcc/fortran/options.c
+++ b/gcc/fortran/options.c
@@ -836,6 +836,10 @@ gfc_handle_option (size_t scode, const char *arg, int value,
       gfc_option.gfc_flag_openmp = value;
       break;
 
+    case OPT_fopenacc:
+      gfc_option.gfc_flag_openacc = value;
+      break;
+
     case OPT_ffree_line_length_none:
       gfc_option.free_line_length = 0;
       break;
diff --git a/gcc/fortran/parse.c b/gcc/fortran/parse.c
index 512babfd450..1971693454e 100644
--- a/gcc/fortran/parse.c
+++ b/gcc/fortran/parse.c
@@ -532,6 +532,88 @@ decode_statement (void)
 }
 
 static gfc_statement
+decode_acc_directive (void)
+{
+  locus old_locus;
+  char c;
+
+  gfc_enforce_clean_symbol_state ();
+
+  gfc_clear_error ();   /* Clear any pending errors.  */
+  gfc_clear_warning (); /* Clear any pending warnings.  */
+
+  if (gfc_pure (NULL))
+    {
+      gfc_error_now ("OpenACC directives at %C may not appear in PURE "
+                     "or ELEMENTAL procedures");
+      gfc_error_recovery ();
+      return ST_NONE;
+    }
+
+  if (gfc_implicit_pure (NULL))
+    gfc_current_ns->proc_name->attr.implicit_pure = 0;
+
+  old_locus = gfc_current_locus;
+
+  /* General OpenACC directive matching: Instead of testing every possible
+     statement, we eliminate most possibilities by peeking at the
+     first character.  */
+
+  c = gfc_peek_ascii_char ();
+
+  switch (c)
+    {
+    case 'c':
+      match ("cache", gfc_match_acc_cache, ST_ACC_CACHE);
+      break;
+    case 'd':
+      match ("data", gfc_match_acc_data, ST_ACC_DATA);
+      match ("declare", gfc_match_acc_declare, ST_ACC_DECLARE);
+      break;
+    case 'e':
+      match ("end data", gfc_match_acc_eos, ST_ACC_END_DATA);
+      match ("end host_data", gfc_match_acc_eos, ST_ACC_END_HOST_DATA);
+      match ("end kernels loop", gfc_match_acc_eos, ST_ACC_END_KERNELS_LOOP);
+      match ("end kernels", gfc_match_acc_eos, ST_ACC_END_KERNELS);
+      match ("end parallel loop", gfc_match_acc_eos, ST_ACC_END_PARALLEL_LOOP);
+      match ("end parallel", gfc_match_acc_eos, ST_ACC_END_PARALLEL);
+      break;
+    case 'h':
+      match ("host_data", gfc_match_acc_host_data, ST_ACC_HOST_DATA);
+      break;
+    case 'p':
+      match ("parallel loop", gfc_match_acc_parallel_loop, ST_ACC_PARALLEL_LOOP);
+      match ("parallel", gfc_match_acc_parallel, ST_ACC_PARALLEL);
+      break;
+    case 'k':
+      match ("kernels loop", gfc_match_acc_kernels_loop, ST_ACC_KERNELS_LOOP);
+      match ("kernels", gfc_match_acc_kernels, ST_ACC_KERNELS);
+      break;
+    case 'l':
+      match ("loop", gfc_match_acc_loop, ST_ACC_LOOP);
+      break;
+    case 'u':
+      match ("update", gfc_match_acc_update, ST_ACC_UPDATE);
+      break;
+    case 'w':
+      match ("wait", gfc_match_acc_wait, ST_ACC_WAIT);
+      break;
+    }
+
+  /* All else has failed, so give up.  See if any of the matchers has
+       stored an error message of some sort.  */
+
+  if (gfc_error_check () == 0)
+    gfc_error_now ("Unclassifiable OpenACC directive at %C");
+
+  reject_statement ();
+
+  gfc_error_recovery ();
+
+  return ST_NONE;
+}
+
+static gfc_statement
 decode_omp_directive (void)
 {
   locus old_locus;
@@ -737,7 +819,7 @@ next_free (void)
   else if (c == '!')
     {
       /* Comments have already been skipped by the time we get here,
-	 except for GCC attributes and OpenMP directives.  */
+	 except for GCC attributes and OpenMP/OpenACC directives.  */
 
       gfc_next_ascii_char (); /* Eat up the exclamation sign.  */
       c = gfc_peek_ascii_char ();
@@ -754,20 +836,73 @@ next_free (void)
 	  return decode_gcc_attribute ();
 
 	}
-      else if (c == '$' && gfc_option.gfc_flag_openmp)
-	{
-	  int i;
-
-	  c = gfc_next_ascii_char ();
-	  for (i = 0; i < 4; i++, c = gfc_next_ascii_char ())
-	    gcc_assert (c == "$omp"[i]);
-
-	  gcc_assert (c == ' ' || c == '\t');
-	  gfc_gobble_whitespace ();
-	  if (last_was_use_stmt)
-	    use_modules ();
-	  return decode_omp_directive ();
-	}
+      else if (c == '$')
+        {
+          /* Since both OpenMP and OpenACC directives starts with !$ character sequence,
+             we must check all flags combinations */
+          if (gfc_option.gfc_flag_openmp && !gfc_option.gfc_flag_openacc)
+            {
+              int i;
+
+              c = gfc_next_ascii_char ();
+              for (i = 0; i < 4; i++, c = gfc_next_ascii_char ())
+                gcc_assert (c == "$omp"[i]);
+
+              gcc_assert (c == ' ' || c == '\t');
+              gfc_gobble_whitespace ();
+              if (last_was_use_stmt)
+                use_modules ();
+              return decode_omp_directive ();
+            }
+          else if (gfc_option.gfc_flag_openmp && gfc_option.gfc_flag_openacc)
+            {
+              gfc_next_ascii_char (); /* Eat up dollar character */
+              c = gfc_peek_ascii_char ();
+
+              if (c == 'o')
+                {
+                  int i;
+
+                  c = gfc_next_ascii_char ();
+                  for (i = 0; i < 3; i++, c = gfc_next_ascii_char ())
+                    gcc_assert (c == "omp"[i]);
+
+                  gcc_assert (c == ' ' || c == '\t');
+                  gfc_gobble_whitespace ();
+                  if (last_was_use_stmt)
+                    use_modules ();
+                  return decode_omp_directive ();
+                }
+              else if (c == 'a')
+                {
+                  int i;
+
+                  c = gfc_next_ascii_char ();
+                  for (i = 0; i < 3; i++, c = gfc_next_ascii_char ())
+                    gcc_assert (c == "acc"[i]);
+
+                  gcc_assert (c == ' ' || c == '\t');
+                  gfc_gobble_whitespace ();
+                  if (last_was_use_stmt)
+                    use_modules ();
+                  return decode_acc_directive ();
+                }
+            }
+          else if (gfc_option.gfc_flag_openacc)
+            {
+              int i;
+
+              c = gfc_next_ascii_char ();
+              for (i = 0; i < 4; i++, c = gfc_next_ascii_char ())
+                gcc_assert (c == "$acc"[i]);
+
+              gcc_assert (c == ' ' || c == '\t');
+              gfc_gobble_whitespace ();
+              if (last_was_use_stmt)
+                use_modules ();
+              return decode_acc_directive ();
+            }
+        }
 
       gcc_unreachable (); 
     }
@@ -843,20 +978,72 @@ next_fixed (void)
 
 	      return decode_gcc_attribute ();
 	    }
-	  else if (c == '$' && gfc_option.gfc_flag_openmp)
+	  else if (c == '$')
 	    {
-	      for (i = 0; i < 4; i++, c = gfc_next_char_literal (NONSTRING))
-		gcc_assert ((char) gfc_wide_tolower (c) == "$omp"[i]);
-
-	      if (c != ' ' && c != '0')
-		{
-		  gfc_buffer_error (0);
-		  gfc_error ("Bad continuation line at %C");
-		  return ST_NONE;
-		}
-	      if (last_was_use_stmt)
-		use_modules ();
-	      return decode_omp_directive ();
+              if (gfc_option.gfc_flag_openmp && !gfc_option.gfc_flag_openacc)
+                {
+                  for (i = 0; i < 4; i++, c = gfc_next_char_literal (NONSTRING))
+                    gcc_assert ((char) gfc_wide_tolower (c) == "$omp"[i]);
+
+                  if (c != ' ' && c != '0')
+                    {
+                      gfc_buffer_error (0);
+                      gfc_error ("Bad continuation line at %C");
+                      return ST_NONE;
+                    }
+                  if (last_was_use_stmt)
+                    use_modules ();
+                  return decode_omp_directive ();
+                }
+              else if (gfc_option.gfc_flag_openmp && gfc_option.gfc_flag_openacc)
+                {
+                  c = gfc_next_char_literal(NONSTRING);
+                  if (c == 'o' || c == 'O')
+                    {
+                      for (i = 0; i < 3; i++, c = gfc_next_char_literal (NONSTRING))
+                        gcc_assert ((char) gfc_wide_tolower (c) == "omp"[i]);
+
+                      if (c != ' ' && c != '0')
+                        {
+                          gfc_buffer_error (0);
+                          gfc_error ("Bad continuation line at %C");
+                          return ST_NONE;
+                        }
+                      if (last_was_use_stmt)
+                        use_modules ();
+                      return decode_omp_directive ();
+                    }
+                  else if (c == 'a' || c == 'A')
+                    {
+                      for (i = 0; i < 3; i++, c = gfc_next_char_literal (NONSTRING))
+                        gcc_assert ((char) gfc_wide_tolower (c) == "acc"[i]);
+
+                      if (c != ' ' && c != '0')
+                        {
+                          gfc_buffer_error (0);
+                          gfc_error ("Bad continuation line at %C");
+                          return ST_NONE;
+                        }
+                      if (last_was_use_stmt)
+                        use_modules ();
+                      return decode_acc_directive ();
+                    }
+                }
+              else if (gfc_option.gfc_flag_openacc)
+                {
+                  for (i = 0; i < 4; i++, c = gfc_next_char_literal (NONSTRING))
+                    gcc_assert ((char) gfc_wide_tolower (c) == "$acc"[i]);
+
+                  if (c != ' ' && c != '0')
+                    {
+                      gfc_buffer_error (0);
+                      gfc_error ("Bad continuation line at %C");
+                      return ST_NONE;
+                    }
+                  if (last_was_use_stmt)
+                    use_modules ();
+                  return decode_acc_directive ();
+                }
 	    }
 	  /* FALLTHROUGH */
 
@@ -1015,7 +1202,8 @@ next_statement (void)
   case ST_LABEL_ASSIGNMENT: case ST_FLUSH: case ST_OMP_FLUSH: \
   case ST_OMP_BARRIER: case ST_OMP_TASKWAIT: case ST_OMP_TASKYIELD: \
   case ST_ERROR_STOP: case ST_SYNC_ALL: case ST_SYNC_IMAGES: \
-  case ST_SYNC_MEMORY: case ST_LOCK: case ST_UNLOCK
+  case ST_SYNC_MEMORY: case ST_LOCK: case ST_UNLOCK: case ST_ACC_UPDATE: \
+  case ST_ACC_WAIT: case ST_ACC_CACHE
 
 /* Statements that mark other executable statements.  */
 
@@ -1027,7 +1215,9 @@ next_statement (void)
   case ST_OMP_CRITICAL: case ST_OMP_MASTER: case ST_OMP_SINGLE: \
   case ST_OMP_DO: case ST_OMP_PARALLEL_DO: case ST_OMP_ATOMIC: \
   case ST_OMP_WORKSHARE: case ST_OMP_PARALLEL_WORKSHARE: \
-  case ST_OMP_TASK: case ST_CRITICAL
+  case ST_OMP_TASK: case ST_CRITICAL: \
+  case ST_ACC_PARALLEL_LOOP: case ST_ACC_PARALLEL: case ST_ACC_KERNELS: \
+  case ST_ACC_DATA: case ST_ACC_HOST_DATA: case ST_ACC_LOOP: case ST_ACC_KERNELS_LOOP
 
 /* Declaration statements */
 
@@ -1054,6 +1244,8 @@ push_state (gfc_state_data *p, gfc_compile_state new_state, gfc_symbol *sym)
   p->sym = sym;
   p->head = p->tail = NULL;
   p->do_variable = NULL;
+  if (p->state != COMP_DO && p->state != COMP_DO_CONCURRENT)
+    p->ext.declare_clauses = NULL;
 
   /* If this the state of a construct like BLOCK, DO or IF, the corresponding
      construct statement was accepted right before pushing the state.  Thus,
@@ -1615,6 +1807,57 @@ gfc_ascii_statement (gfc_statement st)
     case ST_OMP_WORKSHARE:
       p = "!$OMP WORKSHARE";
       break;
+    case ST_ACC_PARALLEL_LOOP:
+      p = "!$ACC PARALLEL LOOP";
+      break;
+    case ST_ACC_END_PARALLEL_LOOP:
+      p = "!$ACC END PARALLEL LOOP";
+      break;
+    case ST_ACC_PARALLEL:
+      p = "!$ACC PARALLEL";
+      break;
+    case ST_ACC_END_PARALLEL:
+      p = "!$ACC END PARALLEL";
+      break;
+    case ST_ACC_KERNELS:
+      p = "!$ACC KERNELS";
+      break;
+    case ST_ACC_END_KERNELS:
+      p = "!$ACC END KERNELS";
+      break;
+    case ST_ACC_KERNELS_LOOP:
+      p = "!$ACC KERNELS LOOP";
+      break;
+    case ST_ACC_END_KERNELS_LOOP:
+      p = "!$ACC END KERNELS LOOP";
+      break;
+    case ST_ACC_DATA:
+      p = "!$ACC DATA";
+      break;
+    case ST_ACC_END_DATA:
+      p = "!$ACC END DATA";
+      break;
+    case ST_ACC_HOST_DATA:
+      p = "!$ACC HOST_DATA";
+      break;
+    case ST_ACC_END_HOST_DATA:
+      p = "!$ACC END HOST_DATA";
+      break;
+    case ST_ACC_LOOP:
+      p = "!$ACC LOOP";
+      break;
+    case ST_ACC_DECLARE:
+      p = "!$ACC DECLARE";
+      break;
+    case ST_ACC_UPDATE:
+      p = "!$ACC UPDATE";
+      break;
+    case ST_ACC_WAIT:
+      p = "!$ACC WAIT";
+      break;
+    case ST_ACC_CACHE:
+      p = "!$ACC CACHE";
+      break;
     default:
       gfc_internal_error ("gfc_ascii_statement(): Bad statement code");
     }
@@ -1883,6 +2126,7 @@ verify_st_order (st_state *p, gfc_statement st, bool silent)
     case ST_PUBLIC:
     case ST_PRIVATE:
     case ST_DERIVED_DECL:
+    case ST_ACC_DECLARE:
     case_decl:
       if (p->state >= ORDER_EXEC)
 	goto order;
@@ -2757,6 +3001,22 @@ declSt:
       st = next_statement ();
       goto loop;
 
+      /* In case of !$ACC DECLARE directive we have to transform it to !$ACC DATA construct */
+    case ST_ACC_DECLARE:
+      if (!verify_st_order(&ss, st, false))
+        {
+          reject_statement ();
+          st = next_statement ();
+          goto loop;
+        }
+      if (gfc_state_stack->ext.declare_clauses == NULL)
+        {
+          gfc_state_stack->ext.declare_clauses = new_st.ext.acc_clauses;
+        }
+      accept_statement (st);
+      st = next_statement ();
+      goto loop;
+
     default:
       break;
     }
@@ -3785,6 +4045,112 @@ parse_omp_structured_block (gfc_statement omp_st, bool workshare_stmts_only)
 }
 
 
+/* Parse the statements of an OpenACC structured block.  */
+
+static void
+parse_acc_structured_block (gfc_statement acc_st)
+{
+  gfc_statement st, acc_end_st;
+  gfc_code *cp, *np;
+  gfc_state_data s;
+
+  accept_statement (acc_st);
+
+  cp = gfc_state_stack->tail;
+  push_state (&s, COMP_ACC_STRUCTURED_BLOCK, NULL);
+  np = new_level (cp);
+  np->op = cp->op;
+  np->block = NULL;
+  switch (acc_st)
+    {
+    case ST_ACC_PARALLEL:
+      acc_end_st = ST_ACC_END_PARALLEL;
+      break;
+    case ST_ACC_KERNELS:
+      acc_end_st = ST_ACC_END_KERNELS;
+      break;
+    case ST_ACC_DATA:
+      acc_end_st = ST_ACC_END_DATA;
+      break;
+    case ST_ACC_HOST_DATA:
+      acc_end_st = ST_ACC_END_HOST_DATA;
+      break;
+    default:
+      gcc_unreachable ();
+    }
+
+  do
+    {
+      st = parse_executable (ST_NONE);
+      if (st == ST_NONE)
+        unexpected_eof ();
+      else if (st != acc_end_st)
+        unexpected_statement (st);
+    }
+  while (st != acc_end_st);
+
+  gcc_assert (new_st.op == EXEC_NOP);
+
+  gfc_clear_new_st ();
+  gfc_commit_symbols ();
+  gfc_warning_check ();
+  pop_state ();
+}
+
+/* Parse the statements of OpenACC loop/parallel loop/kernels loop.  */
+
+static gfc_statement
+parse_acc_loop (gfc_statement acc_st)
+{
+  gfc_statement st;
+  gfc_code *cp, *np;
+  gfc_state_data s;
+
+  accept_statement (acc_st);
+
+  cp = gfc_state_stack->tail;
+  push_state (&s, COMP_ACC_STRUCTURED_BLOCK, NULL);
+  np = new_level (cp);
+  np->op = cp->op;
+  np->block = NULL;
+
+  for (;;)
+    {
+      st = next_statement ();
+      if (st == ST_NONE)
+        unexpected_eof ();
+      else if (st == ST_DO)
+        break;
+      else
+        unexpected_statement (st);
+    }
+
+  parse_do_block ();
+  if (gfc_statement_label != NULL
+      && gfc_state_stack->previous != NULL
+      && gfc_state_stack->previous->state == COMP_DO
+      && gfc_state_stack->previous->ext.end_do_label == gfc_statement_label)
+    {
+      pop_state ();
+      return ST_IMPLIED_ENDDO;
+    }
+
+  check_do_closure ();
+  pop_state ();
+
+  st = next_statement ();
+  if (acc_st == ST_ACC_PARALLEL_LOOP && st == ST_ACC_END_PARALLEL_LOOP ||
+      acc_st == ST_ACC_KERNELS_LOOP && st == ST_ACC_END_KERNELS_LOOP)
+    {
+      gcc_assert (new_st.op == EXEC_NOP);
+      gfc_clear_new_st ();
+      gfc_commit_symbols ();
+      gfc_warning_check ();
+      st = next_statement ();
+    }
+  return st;
+}
+
 /* Accept a series of executable statements.  We return the first
    statement that doesn't fit to the caller.  Any block statements are
    passed on to the correct handler, which usually passes the buck
@@ -3910,6 +4276,21 @@ parse_executable (gfc_statement st)
 	  st = parse_omp_atomic ();
 	  continue;
 
+	case ST_ACC_PARALLEL_LOOP:
+	case ST_ACC_KERNELS_LOOP:
+	case ST_ACC_LOOP:
+	  st = parse_acc_loop (st);
+          if (st == ST_IMPLIED_ENDDO)
+            return st;
+	  continue;
+
+	case ST_ACC_PARALLEL:
+	case ST_ACC_KERNELS:
+	case ST_ACC_DATA:
+	case ST_ACC_HOST_DATA:
+	  parse_acc_structured_block (st);
+	  break;
+
 	default:
 	  return st;
 	}
@@ -4193,6 +4574,11 @@ contains:
 
 done:
   gfc_current_ns->code = gfc_state_stack->head;
+  if (gfc_state_stack->state == COMP_PROGRAM ||
+      gfc_state_stack->state == COMP_MODULE ||
+      gfc_state_stack->state == COMP_SUBROUTINE ||
+      gfc_state_stack->state == COMP_FUNCTION)
+    gfc_current_ns->declare_clauses = gfc_state_stack->ext.declare_clauses;
 }
 
 
@@ -4685,7 +5071,7 @@ prog_units:
   pop_state ();
   goto loop;
 
-  done:
+done:
 
   /* Do the resolution.  */
   resolve_all_program_units (gfc_global_ns_list);
diff --git a/gcc/fortran/parse.h b/gcc/fortran/parse.h
index acafe6c52eb..5a608584db3 100644
--- a/gcc/fortran/parse.h
+++ b/gcc/fortran/parse.h
@@ -29,7 +29,8 @@ typedef enum
   COMP_BLOCK_DATA, COMP_INTERFACE, COMP_DERIVED, COMP_DERIVED_CONTAINS,
   COMP_BLOCK, COMP_ASSOCIATE, COMP_IF,
   COMP_DO, COMP_SELECT, COMP_FORALL, COMP_WHERE, COMP_CONTAINS, COMP_ENUM,
-  COMP_SELECT_TYPE, COMP_OMP_STRUCTURED_BLOCK, COMP_CRITICAL, COMP_DO_CONCURRENT
+  COMP_SELECT_TYPE, COMP_OMP_STRUCTURED_BLOCK, COMP_CRITICAL, COMP_DO_CONCURRENT,
+  COMP_ACC_STRUCTURED_BLOCK
 }
 gfc_compile_state;
 
@@ -49,8 +50,10 @@ typedef struct gfc_state_data
   union
   {
     gfc_st_label *end_do_label;
+    gfc_acc_clauses *declare_clauses;
   }
   ext;
+
 }
 gfc_state_data;
 
diff --git a/gcc/fortran/resolve.c b/gcc/fortran/resolve.c
index d33fe49b661..0641a25f08b 100644
--- a/gcc/fortran/resolve.c
+++ b/gcc/fortran/resolve.c
@@ -8991,6 +8991,16 @@ gfc_resolve_blocks (gfc_code *b, gfc_namespace *ns)
 	case EXEC_OMP_TASKWAIT:
 	case EXEC_OMP_TASKYIELD:
 	case EXEC_OMP_WORKSHARE:
+	case EXEC_ACC_PARALLEL_LOOP:
+	case EXEC_ACC_PARALLEL:
+	case EXEC_ACC_KERNELS_LOOP:
+	case EXEC_ACC_KERNELS:
+	case EXEC_ACC_DATA:
+	case EXEC_ACC_HOST_DATA:
+	case EXEC_ACC_LOOP:
+	case EXEC_ACC_UPDATE:
+	case EXEC_ACC_WAIT:
+	case EXEC_ACC_CACHE:
 	  break;
 
 	default:
@@ -9733,6 +9743,14 @@ resolve_code (gfc_code *code, gfc_namespace *ns)
 	      gfc_resolve_blocks (code->block, ns);
 	      gfc_do_concurrent_flag = 2;
 	      break;
+            case EXEC_ACC_PARALLEL:
+            case EXEC_ACC_KERNELS:
+            case EXEC_ACC_DATA:
+            case EXEC_ACC_HOST_DATA:
+            case EXEC_ACC_PARALLEL_LOOP:
+            case EXEC_ACC_KERNELS_LOOP:
+              gfc_resolve_acc_blocks (code, ns);
+              break;
 	    case EXEC_OMP_WORKSHARE:
 	      omp_workshare_save = omp_workshare_flag;
 	      omp_workshare_flag = 1;
@@ -10060,6 +10078,19 @@ resolve_code (gfc_code *code, gfc_namespace *ns)
 	  omp_workshare_flag = omp_workshare_save;
 	  break;
 
+	case EXEC_ACC_PARALLEL_LOOP:
+	case EXEC_ACC_PARALLEL:
+	case EXEC_ACC_KERNELS_LOOP:
+	case EXEC_ACC_KERNELS:
+	case EXEC_ACC_DATA:
+	case EXEC_ACC_HOST_DATA:
+	case EXEC_ACC_LOOP:
+	case EXEC_ACC_UPDATE:
+	case EXEC_ACC_WAIT:
+	case EXEC_ACC_CACHE:
+	  gfc_resolve_acc_directive (code, ns);
+	  break;
+
 	default:
 	  gfc_internal_error ("resolve_code(): Bad statement code");
 	}
@@ -14500,6 +14531,39 @@ resolve_types (gfc_namespace *ns)
 }
 
 
+/* Insert an implicit data construct to the program or function */
+
+static void
+insert_acc_data_construct (gfc_namespace *ns, gfc_acc_clauses *acc_clauses)
+{
+  gfc_code *head = ns->code;
+  gfc_code *tail, *end;
+  gfc_code *new_root = gfc_get_code ();
+  gfc_code *block = gfc_get_code ();
+
+  new_root->op = block->op = EXEC_ACC_DATA;
+  new_root->block = block;
+  new_root->ext.acc_clauses = acc_clauses;
+
+  /* when there are no executable statements */
+  if (head->next == NULL)
+    new_root->next = head;
+  else
+    {
+      /* go to the end of function or program */
+      tail = head;
+      while(tail->next->next)
+        tail = tail->next;
+      end = tail->next;
+
+      new_root->next = end;
+      block->next = head;
+      tail->next = NULL;
+    }
+  ns->code = new_root;
+}
+
+
 /* Call resolve_code recursively.  */
 
 static void
@@ -14526,6 +14590,9 @@ resolve_codes (gfc_namespace *ns)
   old_obstack = labels_obstack;
   bitmap_obstack_initialize (&labels_obstack);
 
+  if (ns->declare_clauses)
+    insert_acc_data_construct(ns, ns->declare_clauses);
+
   resolve_code (ns->code, ns);
 
   bitmap_obstack_release (&labels_obstack);
diff --git a/gcc/fortran/scanner.c b/gcc/fortran/scanner.c
index 882e2d5e06f..fb3577ab435 100644
--- a/gcc/fortran/scanner.c
+++ b/gcc/fortran/scanner.c
@@ -55,9 +55,11 @@ gfc_directorylist *include_dirs, *intrinsic_modules_dirs;
 
 static gfc_file *file_head, *current_file;
 
-static int continue_flag, end_flag, openmp_flag, gcc_attribute_flag;
+static int continue_flag, end_flag, gcc_attribute_flag;
+static int openmp_flag, openacc_flag; /* If !$omp/!&acc occurred in current comment line */
 static int continue_count, continue_line;
 static locus openmp_locus;
+static locus openacc_locus;
 static locus gcc_attribute_locus;
 
 gfc_source_form gfc_current_form;
@@ -732,7 +734,7 @@ skip_gcc_attribute (locus start)
 
 /* Comment lines are null lines, lines containing only blanks or lines
    on which the first nonblank line is a '!'.
-   Return true if !$ openmp conditional compilation sentinel was
+   Return true if !$ openmp or openacc conditional compilation sentinel was
    seen.  */
 
 static bool
@@ -762,58 +764,175 @@ skip_free_comments (void)
       if (c == '!')
 	{
 	  /* Keep the !GCC$ line.  */
-		  if (at_bol && skip_gcc_attribute (start))
+          if (at_bol && skip_gcc_attribute (start))
 	    return false;
 
-	  /* If -fopenmp, we need to handle here 2 things:
-	     1) don't treat !$omp as comments, but directives
-	     2) handle OpenMP conditional compilation, where
+	  /* If -fopenmp/-fopenacc, we need to handle here 2 things:
+	     1) don't treat !$omp/!$acc as comments, but directives
+	     2) handle OpenMP/OpenACC conditional compilation, where
 		!$ should be treated as 2 spaces (for initial lines
 		only if followed by space).  */
-	  if (gfc_option.gfc_flag_openmp && at_bol)
-	    {
-	      locus old_loc = gfc_current_locus;
-	      if (next_char () == '$')
-		{
-		  c = next_char ();
-		  if (c == 'o' || c == 'O')
-		    {
-		      if (((c = next_char ()) == 'm' || c == 'M')
-			  && ((c = next_char ()) == 'p' || c == 'P'))
-			{
-			  if ((c = next_char ()) == ' ' || c == '\t'
-			      || continue_flag)
-			    {
-			      while (gfc_is_whitespace (c))
-				c = next_char ();
-			      if (c != '\n' && c != '!')
-				{
-				  openmp_flag = 1;
-				  openmp_locus = old_loc;
-				  gfc_current_locus = start;
-				  return false;
-				}
-			    }
-			  else
-			    gfc_warning_now ("!$OMP at %C starts a commented "
-					     "line as it neither is followed "
-					     "by a space nor is a "
-					     "continuation line");
-			}
-		      gfc_current_locus = old_loc;
-		      next_char ();
-		      c = next_char ();
-		    }
-		  if (continue_flag || c == ' ' || c == '\t')
-		    {
-		      gfc_current_locus = old_loc;
-		      next_char ();
-		      openmp_flag = 0;
-		      return true;
-		    }
-		}
-	      gfc_current_locus = old_loc;
-	    }
+          if (at_bol)
+            if (gfc_option.gfc_flag_openmp && gfc_option.gfc_flag_openacc)
+              {
+                locus old_loc = gfc_current_locus;
+                if (next_char () == '$')
+                  {
+                    c = next_char ();
+                    if (c == 'o' || c == 'O')
+                      {
+                        if (((c = next_char ()) == 'm' || c == 'M')
+                            && ((c = next_char ()) == 'p' || c == 'P'))
+                          {
+                            if ((c = next_char ()) == ' ' || c == '\t'
+                                || continue_flag)
+                              {
+                                while (gfc_is_whitespace (c))
+                                  c = next_char ();
+                                if (c != '\n' && c != '!')
+                                  {
+                                    openmp_flag = 1;
+                                    openmp_locus = old_loc;
+                                    gfc_current_locus = start;
+                                    return false;
+                                  }
+                              }
+                            else
+                              gfc_warning_now ("!$OMP at %C starts a commented "
+                                               "line as it neither is followed "
+                                               "by a space nor is a "
+                                               "continuation line");
+                          }
+                        gfc_current_locus = old_loc;
+                        next_char ();
+                        c = next_char ();
+                      }
+                    else if (c == 'a' || c == 'A')
+                      {
+                        if (((c = next_char()) == 'c' || c == 'C') && ((c =
+                            next_char()) == 'c' || c == 'C'))
+                          {
+                            if ((c = next_char()) == ' ' || c == '\t'
+                                || continue_flag)
+                              {
+                                while (gfc_is_whitespace (c))
+                                  c = next_char();
+                                if (c != '\n' && c != '!')
+                                  {
+                                    openacc_flag = 1;
+                                    openacc_locus = old_loc;
+                                    gfc_current_locus = start;
+                                    return false;
+                                  }
+                              }
+                            else
+                              gfc_warning_now("!$ACC at %C starts a commented "
+                                  "line as it neither is followed "
+                                  "by a space nor is a "
+                                  "continuation line");
+                          }
+                        gfc_current_locus = old_loc;
+                        next_char();
+                        c = next_char();
+                      }
+                    if (continue_flag || c == ' ' || c == '\t')
+                      {
+                        gfc_current_locus = old_loc;
+                        next_char ();
+                        openmp_flag = 0;
+                        return true;
+                      }
+                  }
+                gfc_current_locus = old_loc;
+              }
+            else if (gfc_option.gfc_flag_openmp&& !gfc_option.gfc_flag_openacc)
+              {
+                locus old_loc = gfc_current_locus;
+                if (next_char () == '$')
+                  {
+                    c = next_char ();
+                    if (c == 'o' || c == 'O')
+                      {
+                        if (((c = next_char ()) == 'm' || c == 'M')
+                            && ((c = next_char ()) == 'p' || c == 'P'))
+                          {
+                            if ((c = next_char ()) == ' ' || c == '\t'
+                                || continue_flag)
+                              {
+                                while (gfc_is_whitespace (c))
+                                  c = next_char ();
+                                if (c != '\n' && c != '!')
+                                  {
+                                    openmp_flag = 1;
+                                    openmp_locus = old_loc;
+                                    gfc_current_locus = start;
+                                    return false;
+                                  }
+                              }
+                            else
+                              gfc_warning_now ("!$OMP at %C starts a commented "
+                                               "line as it neither is followed "
+                                               "by a space nor is a "
+                                               "continuation line");
+                          }
+                        gfc_current_locus = old_loc;
+                        next_char ();
+                        c = next_char ();
+                      }
+                    if (continue_flag || c == ' ' || c == '\t')
+                      {
+                        gfc_current_locus = old_loc;
+                        next_char ();
+                        openmp_flag = 0;
+                        return true;
+                      }
+                  }
+                gfc_current_locus = old_loc;
+              }
+            else if (gfc_option.gfc_flag_openacc && !gfc_option.gfc_flag_openmp)
+              {
+                locus old_loc = gfc_current_locus;
+                if (next_char() == '$')
+                  {
+                    c = next_char();
+                      if (c == 'a' || c == 'A')
+                        {
+                          if (((c = next_char()) == 'c' || c == 'C') && ((c =
+                              next_char()) == 'c' || c == 'C'))
+                            {
+                              if ((c = next_char()) == ' ' || c == '\t'
+                                  || continue_flag)
+                                {
+                                  while (gfc_is_whitespace (c))
+                                    c = next_char();
+                                  if (c != '\n' && c != '!')
+                                    {
+                                      openacc_flag = 1;
+                                      openacc_locus = old_loc;
+                                      gfc_current_locus = start;
+                                      return false;
+                                    }
+                                }
+                              else
+                                gfc_warning_now("!$ACC at %C starts a commented "
+                                    "line as it neither is followed "
+                                    "by a space nor is a "
+                                    "continuation line");
+                            }
+                          gfc_current_locus = old_loc;
+                          next_char();
+                          c = next_char();
+                        }
+                      if (continue_flag || c == ' ' || c == '\t')
+                        {
+                          gfc_current_locus = old_loc;
+                          next_char();
+                          openacc_flag = 0;
+                          return true;
+                        }
+                  }
+                gfc_current_locus = old_loc;
+              }
 	  skip_comment_line ();
 	  continue;
 	}
@@ -824,6 +943,9 @@ skip_free_comments (void)
   if (openmp_flag && at_bol)
     openmp_flag = 0;
 
+  if (openacc_flag && at_bol)
+    openacc_flag = 0;
+
   gcc_attribute_flag = 0;
   gfc_current_locus = start;
   return false;
@@ -886,9 +1008,9 @@ skip_fixed_comments (void)
 	      return;
 	    }
 
-	  /* If -fopenmp, we need to handle here 2 things:
-	     1) don't treat !$omp|c$omp|*$omp as comments, but directives
-	     2) handle OpenMP conditional compilation, where
+	  /* If -fopenmp/-fopenacc, we need to handle here 2 things:
+	     1) don't treat !$omp/!$acc|c$omp/c$acc|*$omp/*$acc as comments, but directives
+	     2) handle OpenMP/OpenACC conditional compilation, where
 		!$|c$|*$ should be treated as 2 spaces if the characters
 		in columns 3 to 6 are valid fixed form label columns
 		characters.  */
@@ -955,6 +1077,67 @@ skip_fixed_comments (void)
 		}
 	      gfc_current_locus = start;
 	    }
+
+          if (gfc_option.gfc_flag_openacc)
+            {
+              if (next_char () == '$')
+                {
+                  c = next_char ();
+                  if (c == 'a' || c == 'A')
+                    {
+                      if (((c = next_char ()) == 'c' || c == 'C')
+                          && ((c = next_char ()) == 'c' || c == 'C'))
+                        {
+                          c = next_char ();
+                          if (c != '\n'
+                              && ((openacc_flag && continue_flag)
+                                  || c == ' ' || c == '\t' || c == '0'))
+                            {
+                              do
+                                c = next_char ();
+                              while (gfc_is_whitespace (c));
+                              if (c != '\n' && c != '!')
+                                {
+                                  /* Canonicalize to *$acc. */
+                                  *start.nextc = '*';
+                                  openacc_flag = 1;
+                                  gfc_current_locus = start;
+                                  return;
+                                }
+                            }
+                        }
+                    }
+                  else
+                    {
+                      int digit_seen = 0;
+
+                      for (col = 3; col < 6; col++, c = next_char ())
+                        if (c == ' ')
+                          continue;
+                        else if (c == '\t')
+                          {
+                            col = 6;
+                            break;
+                          }
+                        else if (c < '0' || c > '9')
+                          break;
+                        else
+                          digit_seen = 1;
+
+                      if (col == 6 && c != '\n'
+                          && ((continue_flag && !digit_seen)
+                              || c == ' ' || c == '\t' || c == '0'))
+                        {
+                          gfc_current_locus = start;
+                          start.nextc[0] = ' ';
+                          start.nextc[1] = ' ';
+                          continue;
+                        }
+                    }
+                }
+              gfc_current_locus = start;
+            }
+
 	  skip_comment_line ();
 	  continue;
 	}
@@ -1025,7 +1208,7 @@ gfc_char_t
 gfc_next_char_literal (gfc_instring in_string)
 {
   locus old_loc;
-  int i, prev_openmp_flag;
+  int i, prev_openmp_flag, prev_openacc_flag;
   gfc_char_t c;
 
   continue_flag = 0;
@@ -1040,7 +1223,7 @@ restart:
 
   if (gfc_current_form == FORM_FREE)
     {
-      bool openmp_cond_flag;
+      bool openmpacc_cond_flag;
 
       if (!in_string && c == '!')
 	{
@@ -1054,6 +1237,11 @@ restart:
 		 sizeof (gfc_current_locus)) == 0)
 	    goto done;
 
+	  if (openacc_flag
+	      && memcmp (&gfc_current_locus, &openacc_locus,
+	         sizeof (gfc_current_locus)) == 0)
+	    goto done;
+
 	  /* This line can't be continued */
 	  do
 	    {
@@ -1108,7 +1296,11 @@ restart:
 	  goto done;
 	}
 
-      prev_openmp_flag = openmp_flag;
+      if (gfc_option.gfc_flag_openmp)
+        prev_openmp_flag = openmp_flag;
+      if (gfc_option.gfc_flag_openacc)
+        prev_openacc_flag = openacc_flag;
+
       continue_flag = 1;
       if (c == '!')
 	skip_comment_line ();
@@ -1132,19 +1324,29 @@ restart:
 	}
 
       /* Now find where it continues. First eat any comment lines.  */
-      openmp_cond_flag = skip_free_comments ();
+      openmpacc_cond_flag = skip_free_comments ();
 
       if (gfc_current_locus.lb != NULL
 	  && continue_line < gfc_linebuf_linenum (gfc_current_locus.lb))
 	continue_line = gfc_linebuf_linenum (gfc_current_locus.lb);
 
-      if (prev_openmp_flag != openmp_flag)
-	{
-	  gfc_current_locus = old_loc;
-	  openmp_flag = prev_openmp_flag;
-	  c = '&';
-	  goto done;
-	}
+      if (gfc_option.gfc_flag_openmp)
+        if (prev_openmp_flag != openmp_flag)
+          {
+            gfc_current_locus = old_loc;
+            openmp_flag = prev_openmp_flag;
+            c = '&';
+            goto done;
+          }
+
+      if (gfc_option.gfc_flag_openacc)
+        if (prev_openacc_flag != openacc_flag)
+          {
+            gfc_current_locus = old_loc;
+            openacc_flag = prev_openacc_flag;
+            c = '&';
+            goto done;
+          }
 
       /* Now that we have a non-comment line, probe ahead for the
 	 first non-whitespace character.  If it is another '&', then
@@ -1168,6 +1370,17 @@ restart:
 	  while (gfc_is_whitespace (c))
 	    c = next_char ();
 	}
+      if (openacc_flag)
+        {
+          for (i = 0; i < 5; i++, c = next_char ())
+            {
+              gcc_assert(gfc_wide_tolower (c) == (unsigned char ) "!$acc"[i]);
+              if (i == 4)
+                old_loc = gfc_current_locus;
+            }
+          while (gfc_is_whitespace (c))
+            c = next_char ();
+        }
 
       if (c != '&')
 	{
@@ -1180,7 +1393,7 @@ restart:
 	    }
 	  /* Both !$omp and !$ -fopenmp continuation lines have & on the
 	     continuation line only optionally.  */
-	  else if (openmp_flag || openmp_cond_flag)
+	  else if (openmp_flag || openacc_flag || openmpacc_cond_flag)
 	    gfc_current_locus.nextc--;
 	  else
 	    {
@@ -1217,7 +1430,11 @@ restart:
 	  gfc_warning_now ("Line truncated at %L", &gfc_current_locus);
 	}
 
-      prev_openmp_flag = openmp_flag;
+      if (gfc_option.gfc_flag_openmp)
+        prev_openmp_flag = openmp_flag;
+      if (gfc_option.gfc_flag_openacc)
+        prev_openacc_flag = openacc_flag;
+
       continue_flag = 1;
       old_loc = gfc_current_locus;
 
@@ -1225,26 +1442,40 @@ restart:
       skip_fixed_comments ();
 
       /* See if this line is a continuation line.  */
-      if (openmp_flag != prev_openmp_flag)
-	{
-	  openmp_flag = prev_openmp_flag;
-	  goto not_continuation;
-	}
-
-      if (!openmp_flag)
+      if (gfc_option.gfc_flag_openmp)
+        if (openmp_flag != prev_openmp_flag)
+          {
+            openmp_flag = prev_openmp_flag;
+            goto not_continuation;
+          }
+      if (gfc_option.gfc_flag_openacc)
+        if (openacc_flag != prev_openacc_flag)
+          {
+            openmp_flag = prev_openmp_flag;
+            goto not_continuation;
+          }
+
+      if (!openmp_flag && !openacc_flag)
 	for (i = 0; i < 5; i++)
 	  {
 	    c = next_char ();
 	    if (c != ' ')
 	      goto not_continuation;
 	  }
-      else
+      else if (openmp_flag)
 	for (i = 0; i < 5; i++)
 	  {
 	    c = next_char ();
 	    if (gfc_wide_tolower (c) != (unsigned char) "*$omp"[i])
 	      goto not_continuation;
 	  }
+      else if (openacc_flag)
+        for (i = 0; i > 5; i++)
+          {
+            c = next_char ();
+            if (gfc_wide_tolower (c) != (unsigned char) "*$omp"[i])
+              goto not_continuation;
+          }
 
       c = next_char ();
       if (c == '0' || c == ' ' || c == '\n')
diff --git a/gcc/fortran/st.c b/gcc/fortran/st.c
index f8b341c0b6c..38dacc49ac5 100644
--- a/gcc/fortran/st.c
+++ b/gcc/fortran/st.c
@@ -215,6 +215,19 @@ gfc_free_statement (gfc_code *p)
     case EXEC_OMP_TASKYIELD:
       break;
 
+    case EXEC_ACC_WAIT:
+    case EXEC_ACC_UPDATE:
+    case EXEC_ACC_CACHE:
+    case EXEC_ACC_LOOP:
+    case EXEC_ACC_DATA:
+    case EXEC_ACC_HOST_DATA:
+    case EXEC_ACC_KERNELS:
+    case EXEC_ACC_KERNELS_LOOP:
+    case EXEC_ACC_PARALLEL:
+    case EXEC_ACC_PARALLEL_LOOP:
+      gfc_free_acc_clauses (p->ext.acc_clauses);
+      break;
+
     default:
       gfc_internal_error ("gfc_free_statement(): Bad statement");
     }
diff --git a/gcc/fortran/trans-openacc.c b/gcc/fortran/trans-openacc.c
new file mode 100644
index 00000000000..b317d05719c
--- /dev/null
+++ b/gcc/fortran/trans-openacc.c
@@ -0,0 +1,1091 @@
+/*
+ */
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tree.h"
+#include "gimple.h"     /* For create_tmp_var_raw.  */
+#include "diagnostic-core.h"    /* For internal_error.  */
+#include "gfortran.h"
+#include "trans.h"
+#include "trans-stmt.h"
+#include "trans-types.h"
+#include "trans-array.h"
+#include "trans-const.h"
+#include "arith.h"
+
+static tree
+gfc_trans_acc_variable (gfc_symbol *sym)
+{
+  tree t = gfc_get_symbol_decl (sym);
+  tree parent_decl;
+  int parent_flag;
+  bool return_value;
+  bool alternate_entry;
+  bool entry_master;
+
+  return_value = sym->attr.function && sym->result == sym;
+  alternate_entry = sym->attr.function && sym->attr.entry
+                    && sym->result == sym;
+  entry_master = sym->attr.result
+                 && sym->ns->proc_name->attr.entry_master
+                 && !gfc_return_by_reference (sym->ns->proc_name);
+  parent_decl = DECL_CONTEXT (current_function_decl);
+
+  if ((t == parent_decl && return_value)
+       || (sym->ns && sym->ns->proc_name
+           && sym->ns->proc_name->backend_decl == parent_decl
+           && (alternate_entry || entry_master)))
+    parent_flag = 1;
+  else
+    parent_flag = 0;
+
+  /* Special case for assigning the return value of a function.
+     Self recursive functions must have an explicit return value.  */
+  if (return_value && (t == current_function_decl || parent_flag))
+    t = gfc_get_fake_result_decl (sym, parent_flag);
+
+  /* Similarly for alternate entry points.  */
+  else if (alternate_entry
+           && (sym->ns->proc_name->backend_decl == current_function_decl
+               || parent_flag))
+    {
+      gfc_entry_list *el = NULL;
+
+      for (el = sym->ns->entries; el; el = el->next)
+        if (sym == el->sym)
+          {
+            t = gfc_get_fake_result_decl (sym, parent_flag);
+            break;
+          }
+    }
+
+  else if (entry_master
+           && (sym->ns->proc_name->backend_decl == current_function_decl
+               || parent_flag))
+    t = gfc_get_fake_result_decl (sym, parent_flag);
+
+  return t;
+}
+
+static inline tree
+gfc_trans_add_clause (tree node, tree tail)
+{
+  ACC_CLAUSE_CHAIN (node) = tail;
+  return node;
+}
+
+static void
+gfc_trans_acc_array_reduction (tree c, gfc_symbol *sym, locus where)
+{
+  gfc_symtree *root1 = NULL, *root2 = NULL, *root3 = NULL, *root4 = NULL;
+  gfc_symtree *symtree1, *symtree2, *symtree3, *symtree4 = NULL;
+  gfc_symbol init_val_sym, outer_sym, intrinsic_sym;
+  gfc_expr *e1, *e2, *e3, *e4;
+  gfc_ref *ref;
+  tree decl, backend_decl, stmt, type, outer_decl;
+  locus old_loc = gfc_current_locus;
+  const char *iname;
+  bool t;
+
+  decl = ACC_CLAUSE_DECL (c);
+  gfc_current_locus = where;
+  type = TREE_TYPE (decl);
+  outer_decl = create_tmp_var_raw (type, NULL);
+  if (TREE_CODE (decl) == PARM_DECL
+      && TREE_CODE (type) == REFERENCE_TYPE
+      && GFC_DESCRIPTOR_TYPE_P (TREE_TYPE (type))
+      && GFC_TYPE_ARRAY_AKIND (TREE_TYPE (type)) == GFC_ARRAY_ALLOCATABLE)
+    {
+      decl = build_fold_indirect_ref (decl);
+      type = TREE_TYPE (type);
+    }
+
+  /* Create a fake symbol for init value.  */
+  memset (&init_val_sym, 0, sizeof (init_val_sym));
+  init_val_sym.ns = sym->ns;
+  init_val_sym.name = sym->name;
+  init_val_sym.ts = sym->ts;
+  init_val_sym.attr.referenced = 1;
+  init_val_sym.declared_at = where;
+  init_val_sym.attr.flavor = FL_VARIABLE;
+  backend_decl = acc_reduction_init (c, gfc_sym_type (&init_val_sym));
+  init_val_sym.backend_decl = backend_decl;
+
+  /* Create a fake symbol for the outer array reference.  */
+  outer_sym = *sym;
+  outer_sym.as = gfc_copy_array_spec (sym->as);
+  outer_sym.attr.dummy = 0;
+  outer_sym.attr.result = 0;
+  outer_sym.attr.flavor = FL_VARIABLE;
+  outer_sym.backend_decl = outer_decl;
+  if (decl != ACC_CLAUSE_DECL (c))
+    outer_sym.backend_decl = build_fold_indirect_ref (outer_decl);
+
+  /* Create fake symtrees for it.  */
+  symtree1 = gfc_new_symtree (&root1, sym->name);
+  symtree1->n.sym = sym;
+  gcc_assert (symtree1 == root1);
+
+  symtree2 = gfc_new_symtree (&root2, sym->name);
+  symtree2->n.sym = &init_val_sym;
+  gcc_assert (symtree2 == root2);
+
+  symtree3 = gfc_new_symtree (&root3, sym->name);
+  symtree3->n.sym = &outer_sym;
+  gcc_assert (symtree3 == root3);
+
+  /* Create expressions.  */
+  e1 = gfc_get_expr ();
+  e1->expr_type = EXPR_VARIABLE;
+  e1->where = where;
+  e1->symtree = symtree1;
+  e1->ts = sym->ts;
+  e1->ref = ref = gfc_get_ref ();
+  ref->type = REF_ARRAY;
+  ref->u.ar.where = where;
+  ref->u.ar.as = sym->as;
+  ref->u.ar.type = AR_FULL;
+  ref->u.ar.dimen = 0;
+  t = gfc_resolve_expr (e1);
+  gcc_assert (t);
+
+  e2 = gfc_get_expr ();
+  e2->expr_type = EXPR_VARIABLE;
+  e2->where = where;
+  e2->symtree = symtree2;
+  e2->ts = sym->ts;
+  t = gfc_resolve_expr (e2);
+  gcc_assert (t);
+
+  e3 = gfc_copy_expr (e1);
+  e3->symtree = symtree3;
+  t = gfc_resolve_expr (e3);
+  gcc_assert (t);
+
+  iname = NULL;
+  switch (ACC_CLAUSE_REDUCTION_CODE (c))
+    {
+    case PLUS_EXPR:
+    case MINUS_EXPR:
+      e4 = gfc_add (e3, e1);
+      break;
+    case MULT_EXPR:
+      e4 = gfc_multiply (e3, e1);
+      break;
+    case TRUTH_ANDIF_EXPR:
+      e4 = gfc_and (e3, e1);
+      break;
+    case TRUTH_ORIF_EXPR:
+      e4 = gfc_or (e3, e1);
+      break;
+    case EQ_EXPR:
+      e4 = gfc_eqv (e3, e1);
+      break;
+    case NE_EXPR:
+      e4 = gfc_neqv (e3, e1);
+      break;
+    case MIN_EXPR:
+      iname = "min";
+      break;
+    case MAX_EXPR:
+      iname = "max";
+      break;
+    case BIT_AND_EXPR:
+      iname = "iand";
+      break;
+    case BIT_IOR_EXPR:
+      iname = "ior";
+      break;
+    case BIT_XOR_EXPR:
+      iname = "ieor";
+      break;
+    default:
+      gcc_unreachable ();
+    }
+  if (iname != NULL)
+    {
+      memset (&intrinsic_sym, 0, sizeof (intrinsic_sym));
+      intrinsic_sym.ns = sym->ns;
+      intrinsic_sym.name = iname;
+      intrinsic_sym.ts = sym->ts;
+      intrinsic_sym.attr.referenced = 1;
+      intrinsic_sym.attr.intrinsic = 1;
+      intrinsic_sym.attr.function = 1;
+      intrinsic_sym.result = &intrinsic_sym;
+      intrinsic_sym.declared_at = where;
+
+      symtree4 = gfc_new_symtree (&root4, iname);
+      symtree4->n.sym = &intrinsic_sym;
+      gcc_assert (symtree4 == root4);
+
+      e4 = gfc_get_expr ();
+      e4->expr_type = EXPR_FUNCTION;
+      e4->where = where;
+      e4->symtree = symtree4;
+      e4->value.function.isym = gfc_find_function (iname);
+      e4->value.function.actual = gfc_get_actual_arglist ();
+      e4->value.function.actual->expr = e3;
+      e4->value.function.actual->next = gfc_get_actual_arglist ();
+      e4->value.function.actual->next->expr = e1;
+    }
+  /* e1 and e3 have been stored as arguments of e4, avoid sharing.  */
+  e1 = gfc_copy_expr (e1);
+  e3 = gfc_copy_expr (e3);
+  t = gfc_resolve_expr (e4);
+  gcc_assert (t);
+
+  /* Create the init statement list.  */
+  pushlevel ();
+  if (GFC_DESCRIPTOR_TYPE_P (type)
+      && GFC_TYPE_ARRAY_AKIND (type) == GFC_ARRAY_ALLOCATABLE)
+    {
+      /* If decl is an allocatable array, it needs to be allocated
+         with the same bounds as the outer var.  */
+      tree rank, size, esize, ptr;
+      stmtblock_t block;
+
+      gfc_start_block (&block);
+
+      gfc_add_modify (&block, decl, outer_sym.backend_decl);
+      rank = gfc_rank_cst[GFC_TYPE_ARRAY_RANK (type) - 1];
+      size = gfc_conv_descriptor_ubound_get (decl, rank);
+      size = fold_build2_loc (input_location, MINUS_EXPR,
+                              gfc_array_index_type, size,
+                              gfc_conv_descriptor_lbound_get (decl, rank));
+      size = fold_build2_loc (input_location, PLUS_EXPR, gfc_array_index_type,
+                              size, gfc_index_one_node);
+      if (GFC_TYPE_ARRAY_RANK (type) > 1)
+        size = fold_build2_loc (input_location, MULT_EXPR,
+                                gfc_array_index_type, size,
+                                gfc_conv_descriptor_stride_get (decl, rank));
+      esize = fold_convert (gfc_array_index_type,
+                            TYPE_SIZE_UNIT (gfc_get_element_type (type)));
+      size = fold_build2_loc (input_location, MULT_EXPR, gfc_array_index_type,
+                              size, esize);
+      size = gfc_evaluate_now (fold_convert (size_type_node, size), &block);
+
+      ptr = gfc_create_var (pvoid_type_node, NULL);
+      gfc_allocate_using_malloc (&block, ptr, size, NULL_TREE);
+      gfc_conv_descriptor_data_set (&block, decl, ptr);
+
+      gfc_add_expr_to_block (&block, gfc_trans_assignment (e1, e2, false,
+                             false));
+      stmt = gfc_finish_block (&block);
+    }
+  else
+    stmt = gfc_trans_assignment (e1, e2, false, false);
+  if (TREE_CODE (stmt) != BIND_EXPR)
+    stmt = build3_v (BIND_EXPR, NULL, stmt, poplevel (1, 0));
+  else
+    poplevel (0, 0);
+  ACC_CLAUSE_REDUCTION_INIT (c) = stmt;
+
+  /* Create the merge statement list.  */
+  pushlevel ();
+  if (GFC_DESCRIPTOR_TYPE_P (type)
+      && GFC_TYPE_ARRAY_AKIND (type) == GFC_ARRAY_ALLOCATABLE)
+    {
+      /* If decl is an allocatable array, it needs to be deallocated
+         afterwards.  */
+      stmtblock_t block;
+
+      gfc_start_block (&block);
+      gfc_add_expr_to_block (&block, gfc_trans_assignment (e3, e4, false,
+                             true));
+      gfc_add_expr_to_block (&block, gfc_trans_dealloc_allocated (decl, false));
+      stmt = gfc_finish_block (&block);
+    }
+  else
+    stmt = gfc_trans_assignment (e3, e4, false, true);
+  if (TREE_CODE (stmt) != BIND_EXPR)
+    stmt = build3_v (BIND_EXPR, NULL, stmt, poplevel (1, 0));
+  else
+    poplevel (0, 0);
+  ACC_CLAUSE_REDUCTION_MERGE (c) = stmt;
+
+  /* And stick the placeholder VAR_DECL into the clause as well.  */
+  ACC_CLAUSE_REDUCTION_PLACEHOLDER (c) = outer_decl;
+
+  gfc_current_locus = old_loc;
+
+  gfc_free_expr (e1);
+  gfc_free_expr (e2);
+  gfc_free_expr (e3);
+  gfc_free_expr (e4);
+  free (symtree1);
+  free (symtree2);
+  free (symtree3);
+  free (symtree4);
+  gfc_free_array_spec (outer_sym.as);
+}
+
+static tree
+convert_expr_to_tree(stmtblock_t *block, gfc_expr *expr)
+{
+  gfc_se se;
+  tree result;
+
+  gfc_init_se (&se, NULL );
+  gfc_conv_expr (&se, expr);
+  gfc_add_block_to_block (block, &se.pre);
+  result = gfc_evaluate_now (se.expr, block);
+  gfc_add_block_to_block (block, &se.post);
+
+  return result;
+}
+
+static tree
+gfc_trans_acc_variable_list (stmtblock_t *block, enum acc_clause_code code, gfc_namelist *namelist,
+                             tree list)
+{
+  for (; namelist != NULL; namelist = namelist->next)
+    if (namelist->sym->attr.referenced)
+      {
+        if (!namelist->acc_subarray)
+          {
+            tree t = gfc_trans_acc_variable (namelist->sym);
+            if (t != error_mark_node)
+              {
+                tree node = build_acc_clause (input_location, code);
+                ACC_CLAUSE_DECL (node) = t;
+                ACC_IS_SUBARRAY (node) = false;
+                list = gfc_trans_add_clause (node, list);
+              }
+          }
+        else
+          {
+            tree arr_tree = gfc_trans_acc_variable (namelist->sym);
+            if (arr_tree != error_mark_node)
+              {
+                int i;
+                tree node;
+
+                node = build_acc_clause (input_location, code);
+                ACC_CLAUSE_DECL (node) = arr_tree;
+                ACC_IS_SUBARRAY (node) = 1;
+                ACC_SUBARRAY_DIMENSIONS(node) = namelist->acc_subarray->dimensions;
+
+                for (i = 0; i < namelist->acc_subarray->dimensions; i++)
+                  {
+                    gfc_expr *left_expr, *right_expr;
+
+                    left_expr = gfc_subtract (namelist->acc_subarray->left[i],
+                                             gfc_copy_expr (namelist->sym->as->lower[i]));
+                    ACC_SUBARRAY_LEFT_BOUND (node, i) = convert_expr_to_tree (block, left_expr);
+
+                    right_expr = gfc_subtract (namelist->acc_subarray->right[i],
+                                              gfc_copy_expr (namelist->sym->as->lower[i]));
+                    ACC_SUBARRAY_RIGHT_BOUND (node, i) = convert_expr_to_tree (block, right_expr);;
+
+                    gfc_free_expr (left_expr);
+                    gfc_free_expr (right_expr);
+                  }
+
+                list = gfc_trans_add_clause (node, list);
+              }
+          }
+      }
+  return list;
+}
+
+static tree
+gfc_trans_acc_reduction_list (gfc_namelist *namelist, tree list,
+                              enum tree_code reduction_code, locus where)
+{
+  for (; namelist != NULL; namelist = namelist->next)
+    if (namelist->sym->attr.referenced)
+      {
+        tree t = gfc_trans_acc_variable (namelist->sym);
+        if (t != error_mark_node)
+          {
+            tree node = build_acc_clause (where.lb->location,
+                                          ACC_CLAUSE_REDUCTION);
+            ACC_CLAUSE_DECL (node) = t;
+            ACC_CLAUSE_REDUCTION_CODE (node) = reduction_code;
+            if (namelist->sym->attr.dimension)
+              gfc_trans_acc_array_reduction (node, namelist->sym, where);
+            list = gfc_trans_add_clause (node, list);
+          }
+      }
+  return list;
+}
+
+static tree
+gfc_trans_acc_clauses (stmtblock_t *block, gfc_acc_clauses *clauses,
+                       locus where)
+{
+  tree acc_clauses = NULL_TREE, c;
+  int list;
+  enum acc_clause_code clause_code;
+  gfc_se se;
+
+  if (clauses == NULL)
+    return NULL_TREE;
+
+  for (list = 0; list < ACC_LIST_NUM; list++)
+    {
+      gfc_namelist *n = clauses->lists[list];
+
+      if (n == NULL)
+        continue;
+      if (list >= ACC_LIST_REDUCTION_FIRST
+          && list <= ACC_LIST_REDUCTION_LAST)
+        {
+          enum tree_code reduction_code;
+          switch (list)
+            {
+            case ACC_LIST_PLUS:
+              reduction_code = PLUS_EXPR;
+              break;
+            case ACC_LIST_MULT:
+              reduction_code = MULT_EXPR;
+              break;
+            case ACC_LIST_SUB:
+              reduction_code = MINUS_EXPR;
+              break;
+            case ACC_LIST_AND:
+              reduction_code = TRUTH_ANDIF_EXPR;
+              break;
+            case ACC_LIST_OR:
+              reduction_code = TRUTH_ORIF_EXPR;
+              break;
+            case ACC_LIST_EQV:
+              reduction_code = EQ_EXPR;
+              break;
+            case ACC_LIST_NEQV:
+              reduction_code = NE_EXPR;
+              break;
+            case ACC_LIST_MAX:
+              reduction_code = MAX_EXPR;
+              break;
+            case ACC_LIST_MIN:
+              reduction_code = MIN_EXPR;
+              break;
+            case ACC_LIST_IAND:
+              reduction_code = BIT_AND_EXPR;
+              break;
+            case ACC_LIST_IOR:
+              reduction_code = BIT_IOR_EXPR;
+              break;
+            case ACC_LIST_IEOR:
+              reduction_code = BIT_XOR_EXPR;
+              break;
+            default:
+              gcc_unreachable ();
+            }
+          acc_clauses
+            = gfc_trans_acc_reduction_list (n, acc_clauses, reduction_code,
+                                            where);
+          continue;
+        }
+      switch (list)
+        {
+        case ACC_LIST_COPY:
+          clause_code = ACC_CLAUSE_COPY;
+          goto add_clause;
+        case ACC_LIST_COPYIN:
+          clause_code = ACC_CLAUSE_COPYIN;
+          goto add_clause;
+        case ACC_LIST_COPYOUT:
+          clause_code = ACC_CLAUSE_COPYOUT;
+          goto add_clause;
+        case ACC_LIST_CREATE:
+          clause_code = ACC_CLAUSE_CREATE;
+          goto add_clause;
+        case ACC_LIST_PRESENT:
+          clause_code = ACC_CLAUSE_PRESENT;
+          goto add_clause;
+        case ACC_LIST_PRESENT_OR_COPY:
+          clause_code = ACC_CLAUSE_PRESENT_OR_COPY;
+          goto add_clause;
+        case ACC_LIST_PRESENT_OR_COPYIN:
+          clause_code = ACC_CLAUSE_PRESENT_OR_COPYIN;
+          goto add_clause;
+        case ACC_LIST_PRESENT_OR_COPYOUT:
+          clause_code = ACC_CLAUSE_PRESENT_OR_COPYOUT;
+          goto add_clause;
+        case ACC_LIST_PRESENT_OR_CREATE:
+          clause_code = ACC_CLAUSE_PRESENT_OR_CREATE;
+          goto add_clause;
+        case ACC_LIST_USE_DEVICE:
+          clause_code = ACC_CLAUSE_USE_DEVICE;
+          goto add_clause;
+        case ACC_LIST_DEVICEPTR:
+          clause_code = ACC_CLAUSE_DEVICEPTR;
+          goto add_clause;
+        case ACC_LIST_PRIVATE:
+          clause_code = ACC_CLAUSE_PRIVATE;
+          goto add_clause;
+        case ACC_LIST_FIRSTPRIVATE:
+          clause_code = ACC_CLAUSE_FIRSTPRIVATE;
+          goto add_clause;
+        case ACC_LIST_DEVICE_RESIDENT:
+          clause_code = ACC_CLAUSE_DEVICE_RESIDENT;
+          goto add_clause;
+        case ACC_LIST_HOST:
+          clause_code = ACC_CLAUSE_HOST;
+          goto add_clause;
+        case ACC_LIST_DEVICE:
+          clause_code = ACC_CLAUSE_DEVICE;
+          goto add_clause;
+        case ACC_LIST_CACHE:
+          clause_code = ACC_NO_CLAUSE_CACHE;
+          /* FALLTHROUGH */
+        add_clause:
+          acc_clauses
+              = gfc_trans_acc_variable_list (block, clause_code, n, acc_clauses);
+          break;
+        default:
+          break;
+        }
+    }
+
+  if (clauses->if_expr)
+    {
+      tree if_var = convert_expr_to_tree(block, clauses->if_expr);
+      c = build_acc_clause (where.lb->location, ACC_CLAUSE_IF);
+      ACC_CLAUSE_IF_EXPR (c) = if_var;
+      acc_clauses = gfc_trans_add_clause (c, acc_clauses);
+    }
+  if (clauses->async)
+    {
+      c = build_acc_clause (where.lb->location, ACC_CLAUSE_ASYNC);
+      acc_clauses = gfc_trans_add_clause (c, acc_clauses);
+    }
+  if (clauses->seq)
+    {
+      c = build_acc_clause (where.lb->location, ACC_CLAUSE_SEQ);
+      acc_clauses = gfc_trans_add_clause (c, acc_clauses);
+    }
+  if (clauses->independent)
+    {
+      c = build_acc_clause (where.lb->location, ACC_CLAUSE_INDEPENDENT);
+      acc_clauses = gfc_trans_add_clause (c, acc_clauses);
+    }
+  if (clauses->num_gangs_expr)
+    {
+      tree num_gangs_var = convert_expr_to_tree(block, clauses->num_gangs_expr);
+      c = build_acc_clause (where.lb->location, ACC_CLAUSE_NUM_GANGS);
+      ACC_CLAUSE_NUM_GANGS_EXPR (c) = num_gangs_var;
+      acc_clauses = gfc_trans_add_clause (c, acc_clauses);
+    }
+  if (clauses->num_workers_expr)
+    {
+      tree num_workers_var = convert_expr_to_tree(block, clauses->num_workers_expr);
+      c = build_acc_clause (where.lb->location, ACC_CLAUSE_NUM_WORKERS);
+      ACC_CLAUSE_NUM_WORKERS_EXPR (c)= num_workers_var;
+      acc_clauses = gfc_trans_add_clause (c, acc_clauses);
+    }
+  if (clauses->vector_length_expr)
+    {
+      tree vector_length_var = convert_expr_to_tree(block, clauses->vector_length_expr);
+      c = build_acc_clause (where.lb->location, ACC_CLAUSE_VECTOR_LENGTH);
+      ACC_CLAUSE_VECTOR_LENGTH_EXPR (c)= vector_length_var;
+      acc_clauses = gfc_trans_add_clause (c, acc_clauses);
+    }
+  if (clauses->vector)
+    {
+      if (clauses->vector_expr)
+        {
+          tree vector_var = convert_expr_to_tree(block, clauses->vector_expr);
+          c = build_acc_clause (where.lb->location, ACC_CLAUSE_VECTOR);
+          ACC_CLAUSE_VECTOR_EXPR (c)= vector_var;
+          acc_clauses = gfc_trans_add_clause (c, acc_clauses);
+        }
+      else
+        {
+          c = build_acc_clause (where.lb->location, ACC_CLAUSE_VECTOR);
+          acc_clauses = gfc_trans_add_clause (c, acc_clauses);
+        }
+    }
+  if (clauses->worker)
+    {
+      if (clauses->worker_expr)
+        {
+          tree worker_var = convert_expr_to_tree(block, clauses->worker_expr);
+          c = build_acc_clause (where.lb->location, ACC_CLAUSE_WORKER);
+          ACC_CLAUSE_WORKER_EXPR (c)= worker_var;
+          acc_clauses = gfc_trans_add_clause (c, acc_clauses);
+        }
+      else
+        {
+          c = build_acc_clause (where.lb->location, ACC_CLAUSE_WORKER);
+          acc_clauses = gfc_trans_add_clause (c, acc_clauses);
+        }
+    }
+  if (clauses->gang)
+    {
+      if (clauses->gang_expr)
+        {
+          tree gang_var = convert_expr_to_tree(block, clauses->gang_expr);
+          c = build_acc_clause (where.lb->location, ACC_CLAUSE_GANG);
+          ACC_CLAUSE_GANG_EXPR (c)= gang_var;
+          acc_clauses = gfc_trans_add_clause (c, acc_clauses);
+        }
+      else
+        {
+          c = build_acc_clause (where.lb->location, ACC_CLAUSE_GANG);
+          acc_clauses = gfc_trans_add_clause (c, acc_clauses);
+        }
+    }
+  if (clauses->wait_expr)
+    {
+      tree wait_var = convert_expr_to_tree(block, clauses->wait_expr);
+      c = build_acc_clause (where.lb->location, ACC_NO_CLAUSE_WAIT);
+      ACC_WAIT_EXPR (c)= wait_var;
+      acc_clauses = gfc_trans_add_clause (c, acc_clauses);
+    }
+  if (clauses->collapse)
+    {
+      c = build_acc_clause (where.lb->location, ACC_CLAUSE_COLLAPSE);
+      ACC_CLAUSE_COLLAPSE_EXPR (c)
+        = build_int_cst (integer_type_node, clauses->collapse);
+      acc_clauses = gfc_trans_add_clause (c, acc_clauses);
+    }
+
+  return acc_clauses;
+}
+
+static tree
+gfc_trans_acc_code (gfc_code *code, bool force_empty)
+{
+  tree stmt;
+
+  pushlevel ();
+  stmt = gfc_trans_code (code);
+  if (TREE_CODE (stmt) != BIND_EXPR)
+    {
+      if (!IS_EMPTY_STMT (stmt) || force_empty)
+        {
+          tree block = poplevel (1, 0);
+          stmt = build3_v (BIND_EXPR, NULL, stmt, block);
+        }
+      else
+        poplevel (0, 0);
+    }
+  else
+    poplevel (0, 0);
+  return stmt;
+}
+
+//TODO: split into single function
+static tree
+gfc_trans_acc_parallel (gfc_code *code)
+{
+  stmtblock_t block;
+  tree stmt, acc_clauses;
+
+  gfc_start_block (&block);
+  acc_clauses = gfc_trans_acc_clauses (&block, code->ext.acc_clauses,
+                                       code->loc);
+  stmt = gfc_trans_acc_code (code->block->next, true);
+  stmt = build2_loc (input_location, ACC_PARALLEL, void_type_node, stmt,
+                     acc_clauses);
+  gfc_add_expr_to_block (&block, stmt);
+  return gfc_finish_block (&block);
+}
+
+static tree
+gfc_trans_acc_kernels (gfc_code *code)
+{
+  stmtblock_t block;
+  tree stmt, acc_clauses;
+
+  gfc_start_block (&block);
+  acc_clauses = gfc_trans_acc_clauses (&block, code->ext.acc_clauses,
+                                       code->loc);
+  stmt = gfc_trans_acc_code (code->block->next, true);
+  stmt = build2_loc (input_location, ACC_KERNELS, void_type_node, stmt,
+                     acc_clauses);
+  gfc_add_expr_to_block (&block, stmt);
+  return gfc_finish_block (&block);
+}
+
+static tree
+gfc_trans_acc_data (gfc_code *code)
+{
+  stmtblock_t block;
+  tree stmt, acc_clauses;
+
+  gfc_start_block (&block);
+  acc_clauses = gfc_trans_acc_clauses (&block, code->ext.acc_clauses,
+                                       code->loc);
+  stmt = gfc_trans_acc_code (code->block->next, true);
+  stmt = build2_loc (input_location, ACC_DATA, void_type_node, stmt,
+                     acc_clauses);
+  gfc_add_expr_to_block (&block, stmt);
+  return gfc_finish_block (&block);
+}
+
+static tree
+gfc_trans_acc_host_data (gfc_code *code)
+{
+  stmtblock_t block;
+  tree stmt, acc_clauses;
+
+  gfc_start_block (&block);
+  acc_clauses = gfc_trans_acc_clauses (&block, code->ext.acc_clauses,
+                                       code->loc);
+  stmt = gfc_trans_acc_code (code->block->next, true);
+  stmt = build2_loc (input_location, ACC_HOST_DATA, void_type_node, stmt,
+                     acc_clauses);
+  gfc_add_expr_to_block (&block, stmt);
+  return gfc_finish_block (&block);
+}
+
+typedef struct dovar_init_d {
+  tree var;
+  tree init;
+} dovar_init;
+
+/* In statement like DO I = 1, 10 variable i must be private, since i is dovar */
+static tree
+gfc_trans_acc_loop (gfc_code *code, stmtblock_t *pblock,
+                    gfc_acc_clauses *do_clauses)
+{
+  gfc_se se;
+  tree dovar, stmt, from, to, step, type, init, cond, incr;
+  tree count = NULL_TREE, cycle_label, tmp, acc_clauses;
+  stmtblock_t block;
+  stmtblock_t body;
+  gfc_acc_clauses *clauses = code->ext.acc_clauses;
+  int i, collapse = clauses->collapse;
+  vec<dovar_init> inits = vNULL;
+  dovar_init *di;
+  unsigned ix;
+
+  if (collapse <= 0)
+    collapse = 1;
+
+  code = code->block->next;
+  gcc_assert (code->op == EXEC_DO);
+
+  init = make_tree_vec (collapse);
+  cond = make_tree_vec (collapse);
+  incr = make_tree_vec (collapse);
+
+  if (pblock == NULL)
+    {
+      gfc_start_block (&block);
+      pblock = &block;
+    }
+
+  acc_clauses = gfc_trans_acc_clauses (pblock, do_clauses, code->loc);
+
+  for (i = 0; i < collapse; i++)
+    {
+      int simple = 0;
+      int dovar_found = 0;
+      tree dovar_decl;
+
+      /* Evaluate all the expressions in the iterator.  */
+      gfc_init_se (&se, NULL);
+      gfc_conv_expr_lhs (&se, code->ext.iterator->var);
+      gfc_add_block_to_block (pblock, &se.pre);
+      dovar = se.expr;
+      type = TREE_TYPE (dovar);
+      gcc_assert (TREE_CODE (type) == INTEGER_TYPE);
+
+      gfc_init_se (&se, NULL);
+      gfc_conv_expr_val (&se, code->ext.iterator->start);
+      gfc_add_block_to_block (pblock, &se.pre);
+      from = gfc_evaluate_now (se.expr, pblock);
+
+      gfc_init_se (&se, NULL);
+      gfc_conv_expr_val (&se, code->ext.iterator->end);
+      gfc_add_block_to_block (pblock, &se.pre);
+      to = gfc_evaluate_now (se.expr, pblock);
+
+      gfc_init_se (&se, NULL);
+      gfc_conv_expr_val (&se, code->ext.iterator->step);
+      gfc_add_block_to_block (pblock, &se.pre);
+      step = gfc_evaluate_now (se.expr, pblock);
+      dovar_decl = dovar;
+
+      /* Special case simple loops.  */
+      if (TREE_CODE (dovar) == VAR_DECL)
+        {
+          if (integer_onep (step))
+            simple = 1;
+          else if (tree_int_cst_equal (step, integer_minus_one_node))
+            simple = -1;
+        }
+      else
+        dovar_decl
+          = gfc_trans_acc_variable (code->ext.iterator->var->symtree->n.sym);
+
+      /* Loop body.  */
+      if (simple)
+        {
+          TREE_VEC_ELT (init, i) = build2_v (MODIFY_EXPR, dovar, from);
+          /* The condition should not be folded.  */
+          TREE_VEC_ELT (cond, i) = build2_loc (input_location, simple > 0
+                                               ? LE_EXPR : GE_EXPR,
+                                               boolean_type_node, dovar, to);
+          TREE_VEC_ELT (incr, i) = fold_build2_loc (input_location, PLUS_EXPR,
+                                                    type, dovar, step);
+          TREE_VEC_ELT (incr, i) = fold_build2_loc (input_location,
+                                                    MODIFY_EXPR,
+                                                    type, dovar,
+                                                    TREE_VEC_ELT (incr, i));
+        }
+      else
+        {
+          /* STEP is not 1 or -1.  Use:
+             for (count = 0; count < (to + step - from) / step; count++)
+               {
+                 dovar = from + count * step;
+                 body;
+               cycle_label:;
+               }  */
+          tmp = fold_build2_loc (input_location, MINUS_EXPR, type, step, from);
+          tmp = fold_build2_loc (input_location, PLUS_EXPR, type, to, tmp);
+          tmp = fold_build2_loc (input_location, TRUNC_DIV_EXPR, type, tmp,
+                                 step);
+          tmp = gfc_evaluate_now (tmp, pblock);
+          count = gfc_create_var (type, "count");
+          TREE_VEC_ELT (init, i) = build2_v (MODIFY_EXPR, count,
+                                             build_int_cst (type, 0));
+          /* The condition should not be folded.  */
+          TREE_VEC_ELT (cond, i) = build2_loc (input_location, LT_EXPR,
+                                               boolean_type_node,
+                                               count, tmp);
+          TREE_VEC_ELT (incr, i) = fold_build2_loc (input_location, PLUS_EXPR,
+                                                    type, count,
+                                                    build_int_cst (type, 1));
+          TREE_VEC_ELT (incr, i) = fold_build2_loc (input_location,
+                                                    MODIFY_EXPR, type, count,
+                                                    TREE_VEC_ELT (incr, i));
+
+          /* Initialize DOVAR.  */
+          tmp = fold_build2_loc (input_location, MULT_EXPR, type, count, step);
+          tmp = fold_build2_loc (input_location, PLUS_EXPR, type, from, tmp);
+          dovar_init e = {dovar, tmp};
+          inits.safe_push (e);
+        }
+
+      if (!dovar_found)
+        {
+          tmp = build_acc_clause (input_location, ACC_CLAUSE_PRIVATE);
+          ACC_CLAUSE_DECL (tmp) = dovar_decl;
+          acc_clauses = gfc_trans_add_clause (tmp, acc_clauses);
+        }
+      else if (dovar_found == 2)
+        gcc_unreachable();
+      if (!simple)
+        {
+          tmp = build_acc_clause (input_location, ACC_CLAUSE_PRIVATE);
+          ACC_CLAUSE_DECL (tmp) = count;
+          acc_clauses = gfc_trans_add_clause (tmp, acc_clauses);
+        }
+
+      if (i + 1 < collapse)
+        code = code->block->next;
+    }
+
+  if (pblock != &block)
+    {
+      pushlevel ();
+      gfc_start_block (&block);
+    }
+
+  gfc_start_block (&body);
+
+  FOR_EACH_VEC_ELT (inits, ix, di)
+    gfc_add_modify (&body, di->var, di->init);
+  inits.release ();
+
+  /* Cycle statement is implemented with a goto.  Exit statement must not be
+     present for this loop.  */
+  cycle_label = gfc_build_label_decl (NULL_TREE);
+
+  /* Put these labels where they can be found later.  */
+
+  code->cycle_label = cycle_label;
+  code->exit_label = NULL_TREE;
+
+  /* Main loop body.  */
+  tmp = gfc_trans_acc_code (code->block->next, true);
+  gfc_add_expr_to_block (&body, tmp);
+
+  /* Label for cycle statements (if needed).  */
+  if (TREE_USED (cycle_label))
+    {
+      tmp = build1_v (LABEL_EXPR, cycle_label);
+      gfc_add_expr_to_block (&body, tmp);
+    }
+
+  /* End of loop body.  */
+  stmt = make_node (ACC_LOOP);
+
+  TREE_TYPE (stmt) = void_type_node;
+  ACC_LOOP_BODY (stmt) = gfc_finish_block (&body);
+  ACC_LOOP_CLAUSES (stmt) = acc_clauses;
+  ACC_LOOP_INIT (stmt) = init;
+  ACC_LOOP_COND (stmt) = cond;
+  ACC_LOOP_INCR (stmt) = incr;
+  gfc_add_expr_to_block (&block, stmt);
+
+  return gfc_finish_block (&block);
+}
+
+static tree
+gfc_trans_acc_update (gfc_code *code)
+{
+  stmtblock_t block;
+  tree stmt, acc_clauses;
+
+  gfc_start_block (&block);
+  acc_clauses = gfc_trans_acc_clauses (&block, code->ext.acc_clauses,
+                                       code->loc);
+  stmt = build1_loc (input_location, ACC_UPDATE, void_type_node, acc_clauses);
+  gfc_add_expr_to_block (&block, stmt);
+  return gfc_finish_block (&block);
+}
+
+static tree
+gfc_trans_acc_wait (gfc_code *code)
+{
+  stmtblock_t block;
+  tree stmt, acc_clauses;
+
+  gfc_start_block (&block);
+  acc_clauses = gfc_trans_acc_clauses (&block, code->ext.acc_clauses,
+                                       code->loc);
+  stmt = build1_loc (input_location, ACC_WAIT, void_type_node, acc_clauses);
+  gfc_add_expr_to_block (&block, stmt);
+  return gfc_finish_block (&block);
+}
+
+static tree
+gfc_trans_acc_cache (gfc_code *code)
+{
+  stmtblock_t block;
+  tree stmt, acc_clauses;
+
+  gfc_start_block (&block);
+  acc_clauses = gfc_trans_acc_clauses (&block, code->ext.acc_clauses,
+                                       code->loc);
+  stmt = build1_loc (input_location, ACC_CACHE, void_type_node, acc_clauses);
+  gfc_add_expr_to_block (&block, stmt);
+  return gfc_finish_block (&block);
+}
+
+static tree
+gfc_trans_acc_parallel_loop (gfc_code *code)
+{
+  stmtblock_t block, *pblock = NULL;
+  gfc_acc_clauses parallel_clauses, loop_clauses;
+  tree stmt, acc_clauses = NULL_TREE;
+
+  gfc_start_block (&block);
+
+  memset (&loop_clauses, 0, sizeof (loop_clauses));
+  if (code->ext.acc_clauses != NULL)
+    {
+      memcpy (&parallel_clauses, code->ext.acc_clauses,
+              sizeof (parallel_clauses));
+      loop_clauses.collapse = parallel_clauses.collapse;
+      loop_clauses.gang = parallel_clauses.gang;
+      loop_clauses.vector = parallel_clauses.vector;
+      loop_clauses.worker = parallel_clauses.worker;
+      loop_clauses.seq = parallel_clauses.seq;
+      loop_clauses.independent = parallel_clauses.independent;
+      parallel_clauses.collapse = 0;
+      parallel_clauses.gang = false;
+      parallel_clauses.vector = false;
+      parallel_clauses.worker = false;
+      parallel_clauses.seq = false;
+      parallel_clauses.independent = false;
+      acc_clauses = gfc_trans_acc_clauses (&block, &parallel_clauses,
+                                           code->loc);
+    }
+  if (!loop_clauses.seq)
+    pblock = &block;
+  else
+    pushlevel ();
+  stmt = gfc_trans_acc_loop (code, pblock, &loop_clauses);
+  if (TREE_CODE (stmt) != BIND_EXPR)
+    stmt = build3_v (BIND_EXPR, NULL, stmt, poplevel (1, 0));
+  else
+    poplevel (0, 0);
+  stmt = build2_loc (input_location, ACC_PARALLEL, void_type_node, stmt,
+                     acc_clauses);
+  gfc_add_expr_to_block (&block, stmt);
+  return gfc_finish_block (&block);
+}
+
+static tree
+gfc_trans_acc_kernels_loop (gfc_code *code)
+{
+  stmtblock_t block, *pblock = NULL;
+  gfc_acc_clauses kernels_clauses, loop_clauses;
+  tree stmt, acc_clauses = NULL_TREE;
+
+  gfc_start_block (&block);
+
+  memset (&loop_clauses, 0, sizeof (loop_clauses));
+  if (code->ext.acc_clauses != NULL)
+    {
+      memcpy (&kernels_clauses, code->ext.acc_clauses,
+              sizeof (kernels_clauses));
+      loop_clauses.collapse = kernels_clauses.collapse;
+      loop_clauses.gang = kernels_clauses.gang;
+      loop_clauses.vector = kernels_clauses.vector;
+      loop_clauses.worker = kernels_clauses.worker;
+      loop_clauses.seq = kernels_clauses.seq;
+      loop_clauses.independent = kernels_clauses.independent;
+      kernels_clauses.collapse = 0;
+      kernels_clauses.gang = false;
+      kernels_clauses.vector = false;
+      kernels_clauses.worker = false;
+      kernels_clauses.seq = false;
+      kernels_clauses.independent = false;
+      acc_clauses = gfc_trans_acc_clauses (&block, &kernels_clauses,
+                                           code->loc);
+    }
+  if (!loop_clauses.seq)
+    pblock = &block;
+  else
+    pushlevel ();
+  stmt = gfc_trans_acc_loop (code, pblock, &loop_clauses);
+  if (TREE_CODE (stmt) != BIND_EXPR)
+    stmt = build3_v (BIND_EXPR, NULL, stmt, poplevel (1, 0));
+  else
+    poplevel (0, 0);
+  stmt = build2_loc (input_location, ACC_KERNELS, void_type_node, stmt,
+                     acc_clauses);
+  gfc_add_expr_to_block (&block, stmt);
+  return gfc_finish_block (&block);
+}
+
+tree
+gfc_trans_acc_directive (gfc_code *code)
+{
+  switch (code->op)
+    {
+    case EXEC_ACC_PARALLEL_LOOP:
+      return gfc_trans_acc_parallel_loop (code);
+    case EXEC_ACC_PARALLEL:
+      return gfc_trans_acc_parallel (code);
+    case EXEC_ACC_KERNELS_LOOP:
+      return gfc_trans_acc_kernels_loop (code);
+    case EXEC_ACC_KERNELS:
+      return gfc_trans_acc_kernels (code);
+    case EXEC_ACC_DATA:
+      return gfc_trans_acc_data (code);
+    case EXEC_ACC_HOST_DATA:
+      return gfc_trans_acc_host_data (code);
+    case EXEC_ACC_LOOP:
+      return gfc_trans_acc_loop (code, NULL, code->ext.acc_clauses);
+    case EXEC_ACC_UPDATE:
+      return gfc_trans_acc_update (code);
+    case EXEC_ACC_WAIT:
+      return gfc_trans_acc_wait (code);
+    case EXEC_ACC_CACHE:
+      return gfc_trans_acc_cache (code);
+    default:
+      gcc_unreachable ();
+    }
+}
diff --git a/gcc/fortran/trans-stmt.h b/gcc/fortran/trans-stmt.h
index 415f76d79d8..968cb20f699 100644
--- a/gcc/fortran/trans-stmt.h
+++ b/gcc/fortran/trans-stmt.h
@@ -64,6 +64,9 @@ tree gfc_trans_deallocate_array (tree);
 /* trans-openmp.c */
 tree gfc_trans_omp_directive (gfc_code *);
 
+/* trans-openacc.c */
+tree gfc_trans_acc_directive (gfc_code *);
+
 /* trans-io.c */
 tree gfc_trans_open (gfc_code *);
 tree gfc_trans_close (gfc_code *);
diff --git a/gcc/fortran/trans.c b/gcc/fortran/trans.c
index b7863b2d511..31a16a475e5 100644
--- a/gcc/fortran/trans.c
+++ b/gcc/fortran/trans.c
@@ -1849,6 +1849,19 @@ trans_code (gfc_code * code, tree cond)
 	  res = gfc_trans_omp_directive (code);
 	  break;
 
+	case EXEC_ACC_CACHE:
+	case EXEC_ACC_WAIT:
+	case EXEC_ACC_UPDATE:
+	case EXEC_ACC_LOOP:
+	case EXEC_ACC_HOST_DATA:
+	case EXEC_ACC_DATA:
+	case EXEC_ACC_KERNELS:
+	case EXEC_ACC_KERNELS_LOOP:
+	case EXEC_ACC_PARALLEL:
+	case EXEC_ACC_PARALLEL_LOOP:
+	  res = gfc_trans_acc_directive (code);
+	  break;
+
 	default:
 	  internal_error ("gfc_trans_code(): Bad statement code");
 	}
diff --git a/gcc/fortran/types.def b/gcc/fortran/types.def
index e4cd1d18eb9..c32134a14da 100644
--- a/gcc/fortran/types.def
+++ b/gcc/fortran/types.def
@@ -205,3 +205,29 @@ DEF_FUNCTION_TYPE_7 (BT_FN_BOOL_BOOL_ULL_ULL_ULL_ULL_ULLPTR_ULLPTR,
 		     BT_PTR_ULONGLONG, BT_PTR_ULONGLONG)
 
 DEF_FUNCTION_TYPE_VAR_0 (BT_FN_VOID_VAR, BT_VOID)
+
+/*
+ Primitive types and function signatures required by OpenACC 
+*/
+//DEF_PRIMITIVE_TYPE (BT_CONST_STRING, const_string_type_node)
+DEF_FUNCTION_TYPE_1 (BT_FN_INT_INT, BT_INT, BT_INT)
+DEF_POINTER_TYPE (BT_PTR_VOID, BT_VOID)
+
+DEF_FUNCTION_TYPE_1 (BT_FN_VOIDPTR_VOID, BT_PTR_VOID, BT_VOID)
+DEF_FUNCTION_TYPE_1 (BT_FN_VOID_VOIDPTR, BT_VOID, BT_PTR_VOID)
+DEF_FUNCTION_TYPE_1	(BT_FN_VOIDPTR_VOIDPTR, BT_PTR_VOID, BT_PTR_VOID)
+DEF_FUNCTION_TYPE_2 (BT_FN_VOIDPTR_CONST_STRING_CONST_STRING, BT_PTR_VOID,
+			BT_PTR_VOID, BT_PTR_VOID)
+DEF_FUNCTION_TYPE_2 (BT_FN_VOID_VOIDPTR_UINT, BT_VOID, BT_PTR_VOID, BT_UINT)
+DEF_FUNCTION_TYPE_2 (BT_FN_VOIDPTR_CONST_STRING_INT, BT_PTR_VOID,
+			BT_PTR_VOID, BT_INT)
+DEF_FUNCTION_TYPE_2	(BT_FN_VOID_INT_VOIDPTR, BT_VOID, BT_INT, BT_PTR_VOID)
+DEF_FUNCTION_TYPE_3 (BT_FN_VOID_VOIDPTR_UINT_VOIDPTR, BT_VOID, BT_PTR_VOID,
+			BT_UINT, BT_PTR_VOID)
+DEF_FUNCTION_TYPE_3 (BT_FN_VOID_VOIDPTR_UINT_INT, BT_VOID, BT_PTR_VOID, BT_UINT, BT_INT)
+DEF_FUNCTION_TYPE_4 (BT_FN_VOID_VOIDPTR_UINT_VOIDPTR_UINT, BT_VOID, BT_PTR_VOID,
+			BT_UINT, BT_PTR_VOID, BT_UINT)
+DEF_FUNCTION_TYPE_5 (BT_FN_VOIDPTR_VOIDPTR_UNIT_INT_VOIDPTR_UINT, BT_PTR_VOID,
+			BT_PTR_VOID, BT_UINT, BT_INT, BT_PTR_VOID, BT_UINT)
+DEF_FUNCTION_TYPE_5 (BT_FN_VOID_VOIDPTR_UNIT_INT_VOIDPTR_UINT, BT_VOID, BT_PTR_VOID,
+			BT_UINT, BT_INT, BT_PTR_VOID, BT_UINT)
diff --git a/gcc/gcc.c b/gcc/gcc.c
index d48c4db118b..6960383ad7a 100644
--- a/gcc/gcc.c
+++ b/gcc/gcc.c
@@ -782,6 +782,7 @@ proper position among the other output files.  */
     %{s} %{t} %{u*} %{z} %{Z} %{!nostdlib:%{!nostartfiles:%S}} " VTABLE_VERIFICATION_SPEC " \
     %{static:} %{L*} %(mfwrap) %(link_libgcc) " SANITIZER_EARLY_SPEC " %o\
     %{fopenmp|ftree-parallelize-loops=*:%:include(libgomp.spec)%(link_gomp)}\
+    %{fopenacc:%:include(liboacc.spec)%(link_oacc)}\
     %{fgnu-tm:%:include(libitm.spec)%(link_itm)}\
     %(mflib) " STACK_SPLIT_SPEC "\
     %{fprofile-arcs|fprofile-generate*|coverage:-lgcov} " SANITIZER_SPEC " \
diff --git a/gcc/gimple-low.c b/gcc/gimple-low.c
index a46a69f56ed..60d11e72613 100644
--- a/gcc/gimple-low.c
+++ b/gcc/gimple-low.c
@@ -474,6 +474,17 @@ lower_stmt (gimple_stmt_iterator *gsi, struct lower_data *data)
       lower_sequence (gimple_transaction_body_ptr (stmt), data);
       break;
 
+    case GIMPLE_ACC_LOOP:
+    case GIMPLE_ACC_PARALLEL:
+    case GIMPLE_ACC_KERNELS:
+    case GIMPLE_ACC_DATA:
+    case GIMPLE_ACC_CACHE:
+    case GIMPLE_ACC_WAIT:
+    case GIMPLE_ACC_HOST_DATA:
+    case GIMPLE_ACC_DECLARE:
+    case GIMPLE_ACC_UPDATE:
+      break;
+
     default:
       gcc_unreachable ();
     }
diff --git a/gcc/gimple-opencl.c b/gcc/gimple-opencl.c
new file mode 100644
index 00000000000..932e37ad7e9
--- /dev/null
+++ b/gcc/gimple-opencl.c
@@ -0,0 +1,834 @@
+/*
+   This file is part of GCC.
+
+   GCC 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 3, or (at your option) any later
+   version.
+
+   GCC 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 GCC; see the file COPYING3.  If not see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <stdio.h>
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "gimple-pretty-print.h"
+#include "dumpfile.h"
+#include "tree-flow.h"
+#include "tree-ssa.h"
+#include "ssaexpand.h"
+#include "gimple-opencl.h"
+
+static void
+escape_name(FILE* fp, const char* name)
+{
+  /* may be convert to locale? 
+     name = identifier_to_locale(name);
+   */
+  for(; *name; ++name) {
+      if(*name == '.' || *name == '$') {
+          fputc('_', fp);
+      }
+      else {
+          fputc(*name, fp);
+      }
+  }
+}
+
+static void
+generate_name(FILE *fp, tree decl, bool get_asm = false)
+{
+  const char* id;
+  tree name = NULL_TREE;
+  bool is_ssa_name = TREE_CODE(decl) == SSA_NAME;
+  int num = 0;
+
+  if(is_ssa_name) {
+      num = SSA_NAME_VERSION(decl);
+      decl = SSA_NAME_VAR(decl);
+  }
+
+  if(decl) {
+      if(get_asm) {
+          name = DECL_ASSEMBLER_NAME(decl);
+      }
+      if(!name) {
+          name = DECL_NAME(decl);
+      }
+  }
+
+  if(name) {
+      id = IDENTIFIER_POINTER(name);
+  }
+  else {
+      int uid = 0; 
+      if(decl)
+        uid = DECL_UID(decl);
+      id = (const char*)XALLOCAVEC(char, 64);
+      sprintf((char*)id, "_openacc_tmp_%d_%d", uid, num);
+  }
+
+  escape_name(fp, id);
+}
+
+static void
+generate_integer_type(FILE *fp, tree type)
+{
+  unsigned prec = TYPE_PRECISION(type);
+
+  if(prec <= 32) {
+      fprintf(fp, "int ");
+  }
+  else {
+      fprintf(fp, "long int ");
+  }
+}
+
+static void
+generate_real_type(FILE *fp, tree type)
+{
+  unsigned prec = TYPE_PRECISION(type);
+
+  if(prec <= 32) {
+      fprintf(fp, "float ");
+  }
+  else {
+      fprintf(fp, "double ");
+  }
+}
+
+static bool
+generate_type(FILE* fp, tree type, tree decl)
+{
+  bool retval = false;
+
+  switch(TREE_CODE(type)) {
+    case VOID_TYPE:
+      fprintf(fp, "void ");
+      break;
+    case INTEGER_TYPE:
+      generate_integer_type(fp, type);
+      break;
+    case REAL_TYPE:
+      generate_real_type(fp, type);
+      break;
+    case BOOLEAN_TYPE:
+      fprintf(fp, "int ");
+      break;
+    case ARRAY_TYPE:
+      generate_type(fp, TREE_TYPE(type), decl);
+      if(decl != NULL_TREE)
+        generate_name(fp, decl);
+      fprintf(fp, "[] ");
+      retval = true;
+      break;
+    default:
+      gcc_unreachable();
+  }
+  return retval;
+}
+
+static void
+generate_var_decl(FILE* fp, tree decl)
+{
+  bool all_done = generate_type(fp, TREE_TYPE(decl), decl);
+  if(!all_done) {
+      fputc(' ', fp);
+      generate_name(fp, decl);
+  }
+}
+
+static void
+generate_kernel_header(FILE* fp, tree kernel_fn)
+{
+  tree param;
+
+  fprintf(fp, "__kernel ");
+  generate_type(fp, TREE_TYPE(DECL_RESULT(kernel_fn)), NULL_TREE);
+  fprintf(fp, IDENTIFIER_POINTER(DECL_NAME(kernel_fn)));
+  fputc('(', fp);
+  for(param = DECL_ARGUMENTS(kernel_fn); param; param = DECL_CHAIN(param)) {
+      fprintf(fp, "__global ");
+      generate_var_decl(fp, param);
+      if(DECL_CHAIN(param) != NULL_TREE)
+        fputc(',', fp);
+  }
+  fprintf(fp, ")\n");
+}
+
+static void
+generate_locals(FILE* fp, tree kernel_fn)
+{
+  size_t i;
+  tree var;
+
+  FOR_EACH_LOCAL_DECL(DECL_STRUCT_FUNCTION(kernel_fn), i, var) {
+      generate_var_decl(fp, var);
+      fprintf(fp, ";\n");
+  }
+
+  if(gimple_in_ssa_p(cfun)) {
+      for(i = 1; i < num_ssa_names; ++i) {
+          var = ssa_name(i);
+          if(var && !SSA_NAME_VAR(var)) {
+              generate_var_decl(fp, var);
+              fprintf(fp, ";\n");
+          }
+      }
+  }
+
+}
+
+static void
+generate_constant(FILE* fp, tree cnst)
+{
+  switch(TREE_CODE(cnst)) {
+    case INTEGER_CST:
+      if(host_integerp(cnst, 0)) {
+          fprintf(fp, HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT)TREE_INT_CST_LOW(cnst));
+      }
+      else if(host_integerp(cnst, 1)) {
+          fprintf(fp, HOST_WIDE_INT_PRINT_UNSIGNED, (unsigned HOST_WIDE_INT)TREE_INT_CST_LOW(cnst));
+      }
+      break;
+    case REAL_CST:
+        {
+          REAL_VALUE_TYPE x;
+          char buf[128];
+
+          x = TREE_REAL_CST(cnst);
+          real_to_decimal(buf, &x, sizeof(buf), 0, 1);
+          fprintf(fp, buf);
+        }
+      break;
+    case STRING_CST:
+      fprintf(fp, "\"%s\"", TREE_STRING_POINTER(cnst));
+      break;
+    default:
+      gcc_unreachable();
+  }
+}
+
+static void
+generate_expr(FILE* fp, tree expr)
+{
+  if(is_gimple_variable(expr) || DECL_P(expr)) {
+      generate_name(fp, expr);
+  }
+  else if(CONSTANT_CLASS_P(expr)) {
+      generate_constant(fp, expr);
+  }
+  else {
+      switch(TREE_CODE(expr)) {
+        case ARRAY_REF:
+        case MEM_REF:
+          generate_expr(fp, TREE_OPERAND(expr, 0));
+          fprintf(fp, "[");
+          generate_expr(fp, TREE_OPERAND(expr, 1));
+          fprintf(fp, "]");
+          break;
+        case ADDR_EXPR:
+          fprintf(fp, "&");
+          generate_expr(fp, TREE_OPERAND(expr, 0));
+          break;
+        case INDIRECT_REF:
+          fprintf(fp, "*");
+          generate_expr(fp, TREE_OPERAND(expr, 0));
+          break;
+        case COMPONENT_REF:
+          generate_expr(fp, TREE_OPERAND(expr, 0));
+          fprintf(fp, ".");
+          generate_expr(fp, TREE_OPERAND(expr, 1));
+          break;
+        default:
+          gcc_unreachable();
+      }
+  }
+}
+
+static void
+generate_abs_expr(FILE *fp, tree expr)
+{
+  tree type = TREE_TYPE(expr);
+
+  switch(TREE_CODE(type)) {
+    case INTEGER_TYPE:
+      fprintf(fp, "abs(");
+      break;
+    case REAL_TYPE:
+      fprintf(fp, "fabs(");
+      break;
+    default:
+      gcc_unreachable();
+  }
+  generate_expr(fp, expr);
+  fprintf(fp, ")");
+}
+
+static void
+generate_truncate_expr(FILE *fp, tree expr)
+{
+  fprintf(fp, "trunc(");
+  generate_expr(fp, expr);
+  fprintf(fp, ")");
+}
+
+static void
+generate_convert_expr(FILE *fp, tree to_type, tree expr)
+{
+  fprintf(fp, "(");
+  generate_type(fp, to_type, NULL_TREE);
+  fprintf(fp, ")(");
+  generate_expr(fp, expr);
+  fprintf(fp, ")");
+}
+
+static void
+generate_unary_rhs(FILE* fp, enum tree_code code, gimple stmt)
+{
+  tree rhs = gimple_assign_rhs1(stmt);
+
+  switch(code) {
+    case NEGATE_EXPR:
+      fprintf(fp, "-");
+      break;
+    case ABS_EXPR:
+      generate_abs_expr(fp, rhs);
+      return;
+    case BIT_NOT_EXPR:
+      fprintf(fp, "~");
+      break;
+    case TRUTH_NOT_EXPR:
+      fprintf(fp, "!");
+      break;
+    case PREDECREMENT_EXPR:
+      fprintf(fp, "--");
+      break;
+    case PREINCREMENT_EXPR:
+      fprintf(fp, "++");
+      break;
+    case POSTDECREMENT_EXPR:
+      generate_expr(fp, rhs);
+      fprintf(fp, "--");
+      return;
+    case POSTINCREMENT_EXPR:
+      generate_expr(fp, rhs);
+      fprintf(fp, "++");
+      return;
+    case FIX_TRUNC_EXPR:
+      generate_truncate_expr(fp, rhs);
+      return;
+    case NON_LVALUE_EXPR:
+    case NOP_EXPR:
+      break;
+    case FLOAT_EXPR:
+    case CONVERT_EXPR:
+    case FIXED_CONVERT_EXPR:
+      generate_convert_expr(fp, TREE_TYPE(gimple_assign_lhs(stmt)), rhs);
+      return;
+    default:
+      gcc_unreachable();
+  }
+
+  generate_expr(fp, rhs);
+}
+
+static void
+generate_truth_xor(FILE *fp, tree expr1, tree expr2)
+{
+  fprintf(fp, "(((");
+  generate_expr(fp, expr1);
+  fprintf(fp, ") && !(");
+  generate_expr(fp, expr2);
+  fprintf(fp, ")) || (!(");
+  generate_expr(fp, expr1);
+  fprintf(fp, ") && (");
+  generate_expr(fp, expr2);
+  fprintf(fp, ")))");
+}
+
+static void
+generate_floor_div(FILE *fp, tree type, tree expr1, tree expr2)
+{
+  fprintf(fp, "(");
+  generate_type(fp, type, NULL_TREE);
+  fprintf(fp, ") floor((");
+  generate_expr(fp, expr1);
+  fprintf(fp, ")/(");
+  generate_expr(fp, expr2);
+  fprintf(fp, "))");
+
+}
+
+static void
+generate_ceil_div(FILE *fp, tree type, tree expr1, tree expr2)
+{
+  fprintf(fp, "(");
+  generate_type(fp, type, NULL_TREE);
+  fprintf(fp, ") ceil((");
+  generate_expr(fp, expr1);
+  fprintf(fp, ")/(");
+  generate_expr(fp, expr2);
+  fprintf(fp, "))");
+}
+
+static void
+generate_round_div(FILE *fp, tree type, tree expr1, tree expr2)
+{
+  fprintf(fp, "(");
+  generate_type(fp, type, NULL_TREE);
+  fprintf(fp, ") round((");
+  generate_expr(fp, expr1);
+  fprintf(fp, ")/(");
+  generate_expr(fp, expr2);
+  fprintf(fp, "))");
+}
+
+static void
+generate_floor_mod(FILE *fp, tree type, tree expr1, tree expr2)
+{
+  fprintf(fp, "(");
+  generate_type(fp, type, NULL_TREE);
+  fprintf(fp, ") floor( remainder(");
+  generate_expr(fp, expr1);
+  fprintf(fp, ", ");
+  generate_expr(fp, expr2);
+  fprintf(fp, "))");
+}
+
+static void
+generate_ceil_mod(FILE *fp, tree type, tree expr1, tree expr2)
+{
+  fprintf(fp, "(");
+  generate_type(fp, type, NULL_TREE);
+  fprintf(fp, ") ceil( remainder(");
+  generate_expr(fp, expr1);
+  fprintf(fp, ", ");
+  generate_expr(fp, expr2);
+  fprintf(fp, "))");
+}
+
+static void
+generate_round_mod(FILE *fp, tree type, tree expr1, tree expr2)
+{
+  fprintf(fp, "(");
+  generate_type(fp, type, NULL_TREE);
+  fprintf(fp, ") round( remainder(");
+  generate_expr(fp, expr1);
+  fprintf(fp, ", ");
+  generate_expr(fp, expr2);
+  fprintf(fp, "))");
+}
+
+static void
+generate_binary_rhs(FILE* fp, enum tree_code code, gimple stmt)
+{
+  tree rhs1 = gimple_assign_rhs1(stmt);
+  tree rhs2 = gimple_assign_rhs2(stmt);
+
+  switch(code) {
+    case TRUTH_XOR_EXPR:
+      generate_truth_xor(fp, rhs1, rhs2);
+      return;
+    case FLOOR_DIV_EXPR:
+      generate_floor_div(fp, TREE_TYPE(gimple_assign_lhs(stmt)), rhs1, rhs2);
+      return;
+    case CEIL_DIV_EXPR:
+      generate_ceil_div(fp, TREE_TYPE(gimple_assign_lhs(stmt)), rhs1, rhs2);
+      return;
+    case ROUND_DIV_EXPR:
+      generate_round_div(fp, TREE_TYPE(gimple_assign_lhs(stmt)), rhs1, rhs2);
+      return;
+    case FLOOR_MOD_EXPR:
+      generate_floor_mod(fp, TREE_TYPE(gimple_assign_lhs(stmt)), rhs1, rhs2);
+      return;
+    case CEIL_MOD_EXPR:
+      generate_ceil_mod(fp, TREE_TYPE(gimple_assign_lhs(stmt)), rhs1, rhs2);
+      return;
+    case ROUND_MOD_EXPR:
+      generate_round_mod(fp, TREE_TYPE(gimple_assign_lhs(stmt)), rhs1, rhs2);
+      return;
+    default:
+      break;
+  }
+
+  generate_expr(fp, rhs1);
+  switch(code) {
+    case LSHIFT_EXPR:
+      fprintf(fp, " << ");
+      break;
+    case RSHIFT_EXPR:
+      fprintf(fp, " >> ");
+      break;
+    case BIT_IOR_EXPR:
+      fprintf(fp, " | ");
+      break;
+    case BIT_XOR_EXPR:
+      fprintf(fp, " ^ ");
+      break;
+    case BIT_AND_EXPR:
+      fprintf(fp, " & ");
+      break;
+    case TRUTH_ANDIF_EXPR:
+      fprintf(fp, " && ");
+      break;
+    case TRUTH_ORIF_EXPR:
+      fprintf(fp, " || ");
+      break;
+    case TRUTH_AND_EXPR:
+      fprintf(fp, " && ");
+      break;
+    case TRUTH_OR_EXPR:
+      fprintf(fp, " || ");
+      break;
+    case POINTER_PLUS_EXPR:
+      fprintf(fp, " + ");
+      break;
+    case PLUS_EXPR:
+      fprintf(fp, " + ");
+      break;
+    case MINUS_EXPR:
+      fprintf(fp, " - ");
+      break;
+    case MULT_EXPR:
+      fprintf(fp, " * ");
+      break;
+    case TRUNC_DIV_EXPR:
+    case RDIV_EXPR:
+    case EXACT_DIV_EXPR:
+      fprintf(fp, " / ");
+      break;
+    case TRUNC_MOD_EXPR:
+      fprintf(fp, " % ");
+      break;
+
+    case LT_EXPR:
+      fprintf(fp, " < ");
+      break;
+    case LE_EXPR:
+      fprintf(fp, " <= ");
+      break;
+    case GT_EXPR:
+      fprintf(fp, " > ");
+      break;
+    case GE_EXPR:
+      fprintf(fp, " >= ");
+      break;
+    case EQ_EXPR:
+      fprintf(fp, " == ");
+      break;
+    case NE_EXPR:
+      fprintf(fp, " != ");
+      break;
+
+    case UNLT_EXPR:
+      fprintf(fp, " < ");
+      break;
+    case UNLE_EXPR:
+      fprintf(fp, " <= ");
+      break;
+    case UNGT_EXPR:
+      fprintf(fp, " > ");
+      break;
+    case UNGE_EXPR:
+      fprintf(fp, " >= ");
+      break;
+    case UNEQ_EXPR:
+      fprintf(fp, " == ");
+      break;
+    case LTGT_EXPR:
+      fprintf(fp, " != ");
+      break;
+
+    default:
+      gcc_unreachable();
+  }
+  generate_expr(fp, rhs2);
+}
+
+static void
+generate_ternary_rhs(FILE* fp, enum tree_code code, gimple stmt)
+{
+  tree rhs1 = gimple_assign_rhs1(stmt);
+  tree rhs2 = gimple_assign_rhs2(stmt);
+  tree rhs3 = gimple_assign_rhs3(stmt);
+
+  switch(code) {
+    case COND_EXPR:
+      fprintf(fp, "(");
+      generate_expr(fp, rhs1);
+      fprintf(fp, ") ? (");
+      generate_expr(fp, rhs2);
+      fprintf(fp, ") : (");
+      generate_expr(fp, rhs3);
+      fprintf(fp, ")");
+      break;
+    default:
+      gcc_unreachable();
+  }
+
+}
+
+static void
+generate_gimple_assign(FILE* fp, gimple stmt)
+{
+  enum gimple_rhs_class rhs_class = gimple_assign_rhs_class(stmt);
+  enum tree_code code = gimple_assign_rhs_code(stmt);
+
+  generate_expr(fp, gimple_assign_lhs(stmt));
+  fprintf(fp, " = ");
+
+  switch(rhs_class) {
+    case GIMPLE_SINGLE_RHS:
+      generate_expr(fp, gimple_assign_rhs1(stmt));
+      break;
+    case GIMPLE_UNARY_RHS:
+      generate_unary_rhs(fp, code, stmt);
+      break;
+    case GIMPLE_BINARY_RHS:
+      generate_binary_rhs(fp, code, stmt);
+      break;
+    case GIMPLE_TERNARY_RHS:
+      generate_ternary_rhs(fp, code, stmt);
+      break;
+  }
+  fprintf(fp, ";\n");
+}
+
+static void
+generate_gimple_cond(FILE* fp, gimple stmt)
+{
+  enum tree_code code = gimple_cond_code(stmt);
+  tree lhs = gimple_cond_lhs(stmt);
+  tree rhs = gimple_cond_rhs(stmt);
+
+  generate_expr(fp, lhs);
+  switch(code) {
+    case LT_EXPR:
+      fprintf(fp, " < ");
+      break;
+    case LE_EXPR:
+      fprintf(fp, " <= ");
+      break;
+    case GT_EXPR:
+      fprintf(fp, " > ");
+      break;
+    case GE_EXPR:
+      fprintf(fp, " >= ");
+      break;
+    case EQ_EXPR:
+      fprintf(fp, " == ");
+      break;
+    case NE_EXPR:
+      fprintf(fp, " != ");
+      break;
+
+    case UNLT_EXPR:
+      fprintf(fp, " < ");
+      break;
+    case UNLE_EXPR:
+      fprintf(fp, " <= ");
+      break;
+    case UNGT_EXPR:
+      fprintf(fp, " > ");
+      break;
+    case UNGE_EXPR:
+      fprintf(fp, " >= ");
+      break;
+    case UNEQ_EXPR:
+      fprintf(fp, " == ");
+      break;
+    case LTGT_EXPR:
+      fprintf(fp, " != ");
+      break;
+
+    default:
+      gcc_unreachable();
+  }
+  generate_expr(fp, rhs);
+}
+
+static void
+generate_gimple_call(FILE* fp, gimple stmt)
+{
+  tree lhs = gimple_call_lhs(stmt);
+  unsigned i;
+
+  if(TREE_CODE(gimple_call_return_type(stmt)) != VOID_TYPE) {
+      generate_expr(fp, lhs);
+      fprintf(fp, " = ");
+  }
+  generate_name(fp, gimple_call_fndecl(stmt), true);
+  fprintf(fp, "(");
+  for(i = 0; i < gimple_call_num_args(stmt); ++i) {
+      generate_expr(fp, gimple_call_arg(stmt, i));
+      if(i < gimple_call_num_args(stmt) - 1) {
+          fprintf(fp, ", ");
+      }
+  }
+  fprintf(fp, ");\n");
+}
+
+static void
+generate_gimple_return(FILE *fp, gimple stmt)
+{
+  tree ret_val = gimple_return_retval(stmt);
+
+  fprintf(fp, "return ");
+  if(ret_val != NULL_TREE) {
+      generate_expr(fp, ret_val);
+  }
+  fprintf(fp, ";\n");
+}
+
+static void
+generate_gimple_goto(FILE *fp, gimple stmt)
+{
+  tree label = gimple_goto_dest(stmt);
+  if(label != NULL_TREE) {
+      fprintf(fp, "goto ");
+      generate_expr(fp, label);
+      fprintf(fp, ";\n");
+  }
+}
+
+static void
+generate_gimple_label(FILE *fp, gimple stmt)
+{
+  tree label = gimple_label_label(stmt);
+
+  generate_expr(fp, label);
+  fprintf(fp, ":\n");
+}
+
+static void
+generate_gimple_switch(FILE *fp, gimple stmt)
+{
+  // TODO
+  gcc_unreachable();
+}
+
+static void
+generate_stmt(FILE* fp, gimple stmt)
+{
+  fprintf(fp, "// ");
+  print_gimple_stmt(fp, stmt, 0, TDF_RAW);
+
+  switch(gimple_code(stmt)) {
+    case GIMPLE_ASSIGN:
+      generate_gimple_assign(fp, stmt);
+      break;
+    case GIMPLE_COND:
+      fprintf(fp, "if(");
+      generate_gimple_cond(fp, stmt);
+      fprintf(fp, ")\n");
+      break;
+    case GIMPLE_RETURN:
+      generate_gimple_return(fp, stmt);
+      break;
+    case GIMPLE_CALL:
+      generate_gimple_call(fp, stmt);
+      break;
+    case GIMPLE_NOP:
+      fprintf(fp, ";\n");
+      break;
+    case GIMPLE_GOTO:
+      generate_gimple_goto(fp, stmt);
+      break;
+    case GIMPLE_LABEL:
+      generate_gimple_label(fp, stmt);
+      break;
+    case GIMPLE_SWITCH:
+      generate_gimple_switch(fp, stmt);
+      break;
+    case GIMPLE_DEBUG:
+      /* silently ignore */
+      break;
+    default:
+      gcc_unreachable();
+      break;
+  }
+}
+
+static void
+generate_jump(FILE* fp, basic_block bb)
+{
+  fprintf(fp, "goto L%d;", bb->index);
+}
+
+static void
+generate_implicit_gotos(FILE* fp, basic_block bb)
+{
+  edge e;
+  gimple stmt;
+
+  stmt = last_stmt (bb);
+
+  if (stmt && gimple_code (stmt) == GIMPLE_COND) {
+      edge true_edge, false_edge;
+      extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
+
+      generate_jump (fp, true_edge->dest);
+      fprintf(fp, "\n");
+      fprintf(fp, "else\n");
+      generate_jump (fp, false_edge->dest);
+      fprintf(fp, "\n");
+      return;
+  }
+  e = find_fallthru_edge (bb->succs);
+  if (e && e->dest != bb->next_bb) {
+      generate_jump (fp, e->dest);
+      fprintf(fp, "\n");
+  }
+}
+
+static void
+generate_stmts(FILE* fp, tree kernel_fn)
+{
+  basic_block bb;
+
+  FOR_EACH_BB(bb) {
+      fprintf(fp, "L%d:\n", bb->index);
+      gimple_stmt_iterator gsi;
+      for(gsi = gsi_start_bb(bb); !gsi_end_p(gsi); gsi_next(&gsi)) {
+          gimple stmt = gsi_stmt(gsi);
+          generate_stmt(fp, stmt);
+      }
+      generate_implicit_gotos(fp, bb);
+  }
+}
+
+static void
+generate_kernel_body(FILE* fp, tree kernel_fn)
+{
+  fprintf(fp, "{\n");
+  generate_locals(fp, kernel_fn);
+  generate_stmts(fp, kernel_fn);
+  fprintf(fp, "}\n");
+}
+
+
+static void
+generate_kernel(FILE* fp, tree kernel_fn)
+{
+  generate_kernel_header(fp, kernel_fn);
+  generate_kernel_body(fp, kernel_fn);
+}
+
+void
+generate_opencl_kernel(char* cl_file, tree kernel_fn, struct ssaexpand* ssa)
+{
+  FILE* fp;
+
+  fp = fopen(cl_file, "a+t");
+  generate_kernel(fp, kernel_fn);
+  fclose(fp);
+}
+
diff --git a/gcc/gimple-opencl.h b/gcc/gimple-opencl.h
new file mode 100644
index 00000000000..9f3d3775889
--- /dev/null
+++ b/gcc/gimple-opencl.h
@@ -0,0 +1,25 @@
+/*
+   This file is part of GCC.
+
+   GCC 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 3, or (at your option) any later
+   version.
+
+   GCC 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 GCC; see the file COPYING3.  If not see
+   <http://www.gnu.org/licenses/>.  */
+
+#ifndef GIMPLE_OPENCL_H
+#define GIMPLE_OPENCL_H
+
+struct ssaexpand;
+extern void generate_opencl_kernel(char* cl_file, tree kernel_fn, struct ssaexpand* ssa);
+
+
+#endif
diff --git a/gcc/gimple-pretty-print.c b/gcc/gimple-pretty-print.c
index 01a1ab56680..55f87e6d67c 100644
--- a/gcc/gimple-pretty-print.c
+++ b/gcc/gimple-pretty-print.c
@@ -1833,6 +1833,50 @@ dump_gimple_omp_atomic_store (pretty_printer *buffer, gimple gs, int spc,
     }
 }
 
+/* Dump a GIMPLE_ACC_KERNELS tuple on the pretty_printer BUFFER, SPC spaces
+   of indent.  FLAGS specifies details to show in the dump (see TDF_* in
+   dumpfile.h).  */
+
+static void
+dump_gimple_acc_kernels (pretty_printer *buffer, gimple gs, int spc,
+                          int flags)
+{
+	if(flags & TDF_RAW) {
+		dump_gimple_fmt(buffer, spc, flags, "%G <%+BODY <%S> >", gs, gimple_acc_body(gs));
+	}
+	else {
+		gimple_seq body;
+		pp_string(buffer, "#pragma acc kernels");
+    if (gimple_acc_kernels_child_fn (gs))		{
+			pp_string (buffer, " [child fn: ");
+			dump_generic_node (buffer, gimple_acc_kernels_child_fn (gs),
+						 spc, flags, false);
+			pp_string (buffer, " (");
+			//if (gimple_omp_task_data_arg (gs))
+			//	dump_generic_node (buffer, gimple_omp_task_data_arg (gs),
+			//				 spc, flags, false);
+			//else
+			//	pp_string (buffer, "???");
+			pp_string (buffer, ")]");
+		}
+		body = gimple_acc_body(gs);
+		if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND)
+		{
+		  newline_and_indent (buffer, spc + 2);
+		  pp_character (buffer, '{');
+		  pp_newline (buffer);
+		  dump_gimple_seq (buffer, body, spc + 4, flags);
+		  newline_and_indent (buffer, spc + 2);
+		  pp_character (buffer, '}');
+		}
+		else if (body)
+		{
+		  pp_newline (buffer);
+		  dump_gimple_seq (buffer, body, spc + 2, flags);
+		}
+	}
+}
+
 
 /* Dump all the memory operands for statement GS.  BUFFER, SPC and
    FLAGS are as in pp_gimple_stmt_1.  */
@@ -2031,6 +2075,37 @@ pp_gimple_stmt_1 (pretty_printer *buffer, gimple gs, int spc, int flags)
       dump_gimple_omp_critical (buffer, gs, spc, flags);
       break;
 
+
+    case GIMPLE_ACC_PARALLEL:
+      pp_string (buffer, "acc_parallel");
+      break;
+    case GIMPLE_ACC_KERNELS:
+      //pp_string (buffer, "acc_kernels");
+	  dump_gimple_acc_kernels(buffer, gs, spc, flags);
+      break;
+    case GIMPLE_ACC_DATA:
+      pp_string (buffer, "acc_data");
+      break;
+    case GIMPLE_ACC_CACHE:
+      pp_string (buffer, "acc_cache");
+      break;
+    case GIMPLE_ACC_WAIT:
+      pp_string (buffer, "acc_wait");
+      break;
+    case GIMPLE_ACC_HOST_DATA:
+      pp_string (buffer, "acc_host_data");
+      break;
+    case GIMPLE_ACC_LOOP:
+      pp_string (buffer, "acc_loop");
+      break;
+    case GIMPLE_ACC_DECLARE:
+      pp_string (buffer, "acc_declare");
+      break;
+    case GIMPLE_ACC_UPDATE:
+      pp_string (buffer, "acc_update");
+      break;
+
+
     case GIMPLE_CATCH:
       dump_gimple_catch (buffer, gs, spc, flags);
       break;
diff --git a/gcc/gimple.c b/gcc/gimple.c
index 59fcf4335a3..bba12995527 100644
--- a/gcc/gimple.c
+++ b/gcc/gimple.c
@@ -936,7 +936,7 @@ gimple_build_omp_for (gimple_seq body, int kind, tree clauses, size_t collapse,
 
 gimple
 gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn,
-			   tree data_arg)
+                           tree data_arg)
 {
   gimple p = gimple_alloc (GIMPLE_OMP_PARALLEL, 0);
   if (body)
@@ -1119,6 +1119,182 @@ gimple_build_omp_atomic_store (tree val)
   return p;
 }
 
+/********************* Begin of GIMPLE building routines **********************/
+/******************************************************************************/
+
+
+
+/* Set CLAUSES to be associated with ACC_PARALLEL GS.  */
+static inline void
+gimple_acc_parallel_set_clauses (gimple gs, tree clauses)
+{
+  GIMPLE_CHECK (gs, GIMPLE_ACC_PARALLEL);
+  gs->gimple_acc_parallel.clauses = clauses;
+}
+
+/* Return the child function of OMP_PARALLEL GS.  */
+static inline tree
+gimple_acc_parallel_child_fn (const_gimple gs)
+{
+  GIMPLE_CHECK (gs, GIMPLE_ACC_PARALLEL);
+  return gs->gimple_acc_parallel.child_fn;
+}
+
+/* Set CHILD_FN for ACC_PARALLEL GS.  */
+static inline void
+gimple_acc_parallel_set_child_fn (gimple gs, tree child_fn)
+{
+  GIMPLE_CHECK (gs, GIMPLE_ACC_PARALLEL);
+  gs->gimple_acc_parallel.child_fn = child_fn;
+}
+
+/* Set DATA_ARG for ACC_PARALLEL GS.  */
+static inline void
+gimple_acc_parallel_set_data_arg (gimple gs, tree data_arg)
+{
+  GIMPLE_CHECK (gs, GIMPLE_ACC_PARALLEL);
+  gs->gimple_acc_parallel.data_arg = data_arg;
+}
+
+
+gimple
+gimple_build_acc_parallel (gimple_seq body, tree clauses, tree child_fn,
+                           tree data_arg)
+{
+  gimple p = gimple_alloc (GIMPLE_ACC_PARALLEL, 0);
+
+  if (body)
+  {
+    gimple_acc_set_body (p, body);
+  }
+
+  gimple_acc_parallel_set_clauses (p, clauses);
+  gimple_acc_parallel_set_child_fn (p, child_fn);
+  gimple_acc_parallel_set_data_arg (p, data_arg);
+
+  return p;
+}
+
+gimple
+gimple_build_acc_kernels (gimple_seq body, tree clauses, tree child_fn,
+                          tree data_arg)
+{
+  gimple p = gimple_alloc (GIMPLE_ACC_KERNELS, 0);
+
+  if (body)
+  {
+    gimple_acc_set_body (p, body);
+  }
+
+  gimple_acc_kernels_set_clauses (p, clauses);
+  gimple_acc_kernels_set_child_fn (p, child_fn);
+  //gimple_acc_kernels_set_data_arg (p, data_arg);
+
+  return p;
+}
+
+gimple
+gimple_build_acc_data (gimple_seq body, tree clauses, tree child_fn,
+                       tree data_arg)
+{
+  gimple p = gimple_alloc (GIMPLE_ACC_DATA, 0);
+
+  if (body)
+  {
+    gimple_acc_set_body (p, body);
+  }
+
+  return p;
+}
+
+gimple
+gimple_build_acc_cache (gimple_seq body, tree clauses, tree child_fn,
+                        tree data_arg)
+{
+  gimple p = gimple_alloc (GIMPLE_ACC_CACHE, 0);
+
+  if (body)
+  {
+    gimple_acc_set_body (p, body);
+  }
+
+  return p;
+}
+
+gimple
+gimple_build_acc_wait (gimple_seq body, tree clauses, tree child_fn,
+                       tree data_arg)
+{
+  gimple p = gimple_alloc (GIMPLE_ACC_WAIT, 0);
+
+  if (body)
+  {
+    gimple_acc_set_body (p, body);
+  }
+
+  return p;
+}
+
+gimple
+gimple_build_acc_host_data (gimple_seq body, tree clauses, tree child_fn,
+                            tree data_arg)
+{
+  gimple p = gimple_alloc (GIMPLE_ACC_HOST_DATA, 0);
+
+  if (body)
+  {
+    gimple_acc_set_body (p, body);
+  }
+
+  return p;
+}
+
+gimple
+gimple_build_acc_loop (gimple_seq body, tree clauses, tree child_fn,
+                       tree data_arg)
+{
+  gimple p = gimple_alloc (GIMPLE_ACC_LOOP, 0);
+
+  if (body)
+  {
+    gimple_acc_set_body (p, body);
+  }
+
+  return p;
+}
+
+gimple
+gimple_build_acc_declare (gimple_seq body, tree clauses, tree child_fn,
+                          tree data_arg)
+{
+  gimple p = gimple_alloc (GIMPLE_ACC_DECLARE, 0);
+
+  if (body)
+  {
+    gimple_acc_set_body (p, body);
+  }
+
+  return p;
+}
+
+gimple
+gimple_build_acc_update (gimple_seq body, tree clauses, tree child_fn,
+                         tree data_arg)
+{
+  gimple p = gimple_alloc (GIMPLE_ACC_UPDATE, 0);
+
+  if (body)
+  {
+    gimple_acc_set_body (p, body);
+  }
+
+  return p;
+}
+
+
+/********************** End of GIMPLE building routines ***********************/
+/******************************************************************************/
+
 /* Build a GIMPLE_TRANSACTION statement.  */
 
 gimple
@@ -1794,6 +1970,32 @@ walk_gimple_stmt (gimple_stmt_iterator *gsi, walk_stmt_fn callback_stmt,
 	return wi->callback_result;
       break;
 
+/*  case GIMPLE_ACC_LOOP:
+      ret = walk_gimple_seq_mod (gimple_acc_for_pre_body_ptr (stmt),
+                                 callback_stmt,
+                                 callback_op,
+                                 wi);
+      if (ret)
+        return wi->callback_result;*/
+
+      /* FALL THROUGH.  */
+    case GIMPLE_ACC_PARALLEL:
+    case GIMPLE_ACC_KERNELS:
+    case GIMPLE_ACC_DATA:
+    case GIMPLE_ACC_CACHE:
+    case GIMPLE_ACC_WAIT:
+    case GIMPLE_ACC_HOST_DATA:
+    case GIMPLE_ACC_DECLARE:
+    case GIMPLE_ACC_UPDATE:
+      ret = walk_gimple_seq_mod (gimple_acc_body_ptr (stmt),
+                                 callback_stmt,
+                                 callback_op,
+                                 wi);
+
+      if (ret)
+        return wi->callback_result;
+      break;
+
     case GIMPLE_WITH_CLEANUP_EXPR:
       ret = walk_gimple_seq_mod (gimple_wce_cleanup_ptr (stmt), callback_stmt,
 			     callback_op, wi);
diff --git a/gcc/gimple.def b/gcc/gimple.def
index f3652f4e78f..cbe1dc0d34c 100644
--- a/gcc/gimple.def
+++ b/gcc/gimple.def
@@ -349,6 +349,18 @@ DEFGSCODE(GIMPLE_OMP_SECTIONS_SWITCH, "gimple_omp_sections_switch", GSS_BASE)
    CLAUSES is an OMP_CLAUSE chain holding the associated clauses.  */
 DEFGSCODE(GIMPLE_OMP_SINGLE, "gimple_omp_single", GSS_OMP_SINGLE)
 
+/* OpenACC DEFGSCODEs */
+DEFGSCODE(GIMPLE_ACC, "gimple_acc", GSS_ACC)
+DEFGSCODE(GIMPLE_ACC_PARALLEL, "gimple_acc_parallel", GSS_ACC_PARALLEL)
+DEFGSCODE(GIMPLE_ACC_KERNELS, "gimple_acc_kernels", GSS_ACC_KERNELS)
+DEFGSCODE(GIMPLE_ACC_DATA, "gimple_acc_data", GSS_ACC_DATA)
+DEFGSCODE(GIMPLE_ACC_CACHE, "gimple_acc_cache", GSS_ACC_CACHE)
+DEFGSCODE(GIMPLE_ACC_WAIT, "gimple_acc_wait", GSS_ACC_WAIT)
+DEFGSCODE(GIMPLE_ACC_HOST_DATA, "gimple_acc_host_data", GSS_ACC_HOST_DATA)
+DEFGSCODE(GIMPLE_ACC_LOOP, "gimple_acc_loop", GSS_ACC_LOOP)
+DEFGSCODE(GIMPLE_ACC_DECLARE, "gimple_acc_declare", GSS_ACC_DECLARE)
+DEFGSCODE(GIMPLE_ACC_UPDATE, "gimple_acc_update", GSS_ACC_UPDATE)
+
 /* GIMPLE_PREDICT <PREDICT, OUTCOME> specifies a hint for branch prediction.
 
    PREDICT is one of the predictors from predict.def.
diff --git a/gcc/gimple.h b/gcc/gimple.h
index 5f1280586d2..46e306a89aa 100644
--- a/gcc/gimple.h
+++ b/gcc/gimple.h
@@ -317,6 +317,16 @@ struct GTY(()) gimple_statement_omp {
   gimple_seq body;
 };
 
+/* OpenACC statements (#pragma acc).  */
+
+struct GTY(()) gimple_statement_acc {
+  /* [ WORD 1-6 ]  */
+  struct gimple_statement_base gsbase;
+
+  /* [ WORD 7 ]  */
+  gimple_seq body;
+};
+
 
 /* GIMPLE_BIND */
 
@@ -649,6 +659,169 @@ struct GTY(()) gimple_statement_omp_atomic_store {
   tree val;
 };
 
+
+/* GIMPLE OpenACC structs */
+/* GIMPLE_ACC_LOOP_ITER */
+
+struct GTY(()) gimple_acc_loop_iter {
+  /* Condition code.  */
+  enum tree_code cond;
+
+  /* Index variable.  */
+  tree index;
+
+  /* Initial value.  */
+  tree initial;
+
+  /* Final value.  */
+  tree final;
+
+  /* Increment.  */
+  tree incr;
+};
+
+/* GIMPLE_ACC_LOOP */
+
+struct GTY(()) gimple_statement_acc_loop {
+  /* [ WORD 1-7 ]  */
+  struct gimple_statement_acc acc;
+
+  /* [ WORD 8 ]  */
+  tree clauses;
+
+  /* [ WORD 9 ]
+     Number of elements in iter array.  */
+  size_t collapse;
+
+  /* [ WORD 10 ]  */
+  struct gimple_acc_loop_iter * GTY((length ("%h.collapse"))) iter;
+
+  /* [ WORD 11 ]
+     Pre-body evaluated before the loop body begins.  */
+  gimple_seq pre_body;
+};
+
+
+/* GIMPLE_ACC_PARALLEL */
+
+struct GTY(()) gimple_statement_acc_parallel {
+  /* [ WORD 1-7 ]  */
+  struct gimple_statement_acc acc;
+
+  /* [ WORD 8 ]
+     Clauses.  */
+  tree clauses;
+
+  /* [ WORD 9 ]
+     Child function holding the body of the parallel region.  */
+  tree child_fn;
+
+  /* [ WORD 10 ]
+     Shared data argument.  */
+  tree data_arg;
+};
+
+
+/* GIMPLE_ACC_KERNELS */
+
+struct GTY(()) gimple_statement_acc_kernels {
+  ///* [ WORD 1-7 ]  */
+  //struct gimple_statement_acc acc;
+  /* [ WORD 1-9 ]  */
+  struct gimple_statement_with_memory_ops_base membase;
+
+  /* [ WORD 10 ]  */
+  gimple_seq body;
+
+  /* [ WORD 11 ]
+     Clauses.  */
+  tree clauses;
+
+  /* [ WORD 12 ]
+     Child function holding the body of the kernels region.  */
+  tree child_fn;
+
+  //tree data_arg;
+	//unsigned nparams;
+  /* [ WORD 13 ]
+     Shared data argument.  */
+	tree GTY((length("%h.membase.opbase.gsbase.num_ops"))) op[1];
+};
+
+/* GIMPLE_ACC_DATA */
+
+struct GTY(()) gimple_statement_acc_data {
+  /* [ WORD 1-7 ]  */
+  struct gimple_statement_acc acc;
+
+  /* [ WORD 8 ]
+     Clauses.  */
+  tree clauses;
+
+  /* [ WORD 9 ]
+     Child region.  */
+  tree child_fn;
+};
+
+/* GIMPLE_ACC_HOST_DATA */
+
+struct GTY(()) gimple_statement_acc_host_data {
+  /* [ WORD 1-7 ]  */
+  struct gimple_statement_acc acc;
+
+  /* [ WORD 8 ]
+     Clauses.  */
+  tree clauses;
+
+  /* [ WORD 9 ]
+     Child region.  */
+  tree child_fn;
+};
+
+/* GIMPLE_ACC_CACHE */
+
+struct GTY(()) gimple_statement_acc_cache {
+  /* [ WORD 1-7 ]  */
+  struct gimple_statement_acc acc;
+
+  /* [ WORD 8 ]
+     List of cache arguments.  */
+  tree list_arg;
+};
+
+/* GIMPLE_ACC_WAIT */
+
+struct GTY(()) gimple_statement_acc_wait {
+  /* [ WORD 1-7 ]  */
+  struct gimple_statement_acc acc;
+
+  /* [ WORD 8 ]
+     scalar-integer-expression  */
+  tree expression;
+};
+
+/* GIMPLE_ACC_DECLARE */
+
+struct GTY(()) gimple_statement_acc_declare {
+  /* [ WORD 1-7 ]  */
+  struct gimple_statement_acc acc;
+
+  /* [ WORD 8 ]
+     Clauses.  */
+  tree clauses;
+};
+
+/* GIMPLE_ACC_UPDATE */
+
+struct GTY(()) gimple_statement_acc_update {
+  /* [ WORD 1-7 ]  */
+  struct gimple_statement_acc acc;
+
+  /* [ WORD 8 ]
+     Clauses.  */
+  tree clauses;
+};
+
 /* GIMPLE_TRANSACTION.  */
 
 /* Bits to be stored in the GIMPLE_TRANSACTION subcode.  */
@@ -727,6 +900,19 @@ union GTY ((desc ("gimple_statement_structure (&%h)"),
   struct gimple_statement_omp_continue GTY ((tag ("GSS_OMP_CONTINUE"))) gimple_omp_continue;
   struct gimple_statement_omp_atomic_load GTY ((tag ("GSS_OMP_ATOMIC_LOAD"))) gimple_omp_atomic_load;
   struct gimple_statement_omp_atomic_store GTY ((tag ("GSS_OMP_ATOMIC_STORE"))) gimple_omp_atomic_store;
+
+  /* OpenACC */
+  struct gimple_statement_acc GTY ((tag ("GSS_ACC"))) acc;
+  struct gimple_statement_acc_parallel GTY ((tag ("GSS_ACC_PARALLEL"))) gimple_acc_parallel;
+  struct gimple_statement_acc_kernels GTY ((tag ("GSS_ACC_KERNELS"))) gimple_acc_kernels;
+  struct gimple_statement_acc_data GTY ((tag ("GSS_ACC_DATA"))) gimple_acc_data;
+  struct gimple_statement_acc_cache GTY ((tag ("GSS_ACC_CACHE"))) gimple_acc_cache;
+  struct gimple_statement_acc_wait GTY ((tag ("GSS_ACC_WAIT"))) gimple_acc_wait;
+  struct gimple_statement_acc_host_data GTY ((tag ("GSS_ACC_HOST_DATA"))) gimple_acc_host_data;
+  struct gimple_statement_acc_loop GTY ((tag ("GSS_ACC_LOOP"))) gimple_acc_loop;
+  struct gimple_statement_acc_declare GTY ((tag ("GSS_ACC_DECLARE"))) gimple_acc_declare;
+  struct gimple_statement_acc_update GTY ((tag ("GSS_ACC_UPDATE"))) gimple_acc_update;
+
   struct gimple_statement_transaction GTY((tag ("GSS_TRANSACTION"))) gimple_transaction;
 };
 
@@ -815,6 +1001,18 @@ gimple gimple_build_omp_single (gimple_seq, tree);
 gimple gimple_build_cdt (tree, tree);
 gimple gimple_build_omp_atomic_load (tree, tree);
 gimple gimple_build_omp_atomic_store (tree);
+
+/* TODO FIX ACC Check arguments number */
+gimple gimple_build_acc_parallel (gimple_seq, tree, tree, tree);
+gimple gimple_build_acc_kernels (gimple_seq, tree, tree, tree);
+gimple gimple_build_acc_data (gimple_seq, tree, tree, tree);
+gimple gimple_build_acc_cache (gimple_seq, tree, tree, tree);
+gimple gimple_build_acc_wait (gimple_seq, tree, tree, tree);
+gimple gimple_build_acc_host_data (gimple_seq, tree, tree, tree);
+gimple gimple_build_acc_loop (gimple_seq, tree, tree, tree);
+gimple gimple_build_acc_declare (gimple_seq, tree, tree, tree);
+gimple gimple_build_acc_update (gimple_seq, tree, tree, tree);
+
 gimple gimple_build_transaction (gimple_seq, tree);
 gimple gimple_build_predict (enum br_predictor, enum prediction);
 enum gimple_statement_structure_enum gss_for_assign (enum tree_code);
@@ -1082,6 +1280,7 @@ extern tree canonicalize_cond_expr_cond (tree);
 
 /* In omp-low.c.  */
 extern tree omp_reduction_init (tree, tree);
+extern tree acc_reduction_init (tree, tree);
 
 /* In trans-mem.c.  */
 extern void diagnose_tm_safe_errors (tree);
@@ -1261,6 +1460,17 @@ gimple_has_substatements (gimple g)
     case GIMPLE_OMP_SECTIONS:
     case GIMPLE_OMP_SINGLE:
     case GIMPLE_OMP_CRITICAL:
+
+    case GIMPLE_ACC_PARALLEL:
+    case GIMPLE_ACC_KERNELS:
+    case GIMPLE_ACC_LOOP:
+    case GIMPLE_ACC_DATA:
+    case GIMPLE_ACC_HOST_DATA:
+    case GIMPLE_ACC_CACHE:
+    case GIMPLE_ACC_DECLARE:
+    case GIMPLE_ACC_UPDATE:
+    case GIMPLE_ACC_WAIT:
+
     case GIMPLE_WITH_CLEANUP_EXPR:
     case GIMPLE_TRANSACTION:
       return true;
@@ -4909,6 +5119,101 @@ gimple_return_set_retval (gimple gs, tree retval)
   gimple_set_op (gs, 0, retval);
 }
 
+#define CASE_GIMPLE_ACC \
+    case GIMPLE_ACC_PARALLEL: \
+    case GIMPLE_ACC_KERNELS: \
+    case GIMPLE_ACC_DATA: \
+    case GIMPLE_ACC_CACHE: \
+    case GIMPLE_ACC_WAIT: \
+    case GIMPLE_ACC_HOST_DATA: \
+    case GIMPLE_ACC_LOOP: \
+    case GIMPLE_ACC_DECLARE: \
+    case GIMPLE_ACC_UPDATE
+
+static inline bool
+is_gimple_acc (const_gimple stmt)
+{
+  switch (gimple_code (stmt))
+  {
+  CASE_GIMPLE_ACC:
+    return true;
+  default:
+    return false;
+  }
+}
+
+/* Set BODY to be for the ACC statement GS.  */
+static inline void
+gimple_acc_set_body (gimple gs, gimple_seq body)
+{
+  gs->acc.body = body;
+}
+
+static inline gimple_seq *
+gimple_acc_body_ptr (gimple gs)
+{
+  return &gs->acc.body;
+}
+
+static inline gimple_seq
+gimple_acc_body (gimple gs)
+{
+  return *gimple_acc_body_ptr (gs);
+}
+
+/* Return the child function of ACC_KERNELS GS.  */
+static inline tree
+gimple_acc_kernels_child_fn (const_gimple gs)
+{
+  GIMPLE_CHECK (gs, GIMPLE_ACC_KERNELS);
+  return gs->gimple_acc_kernels.child_fn;
+}
+
+static inline unsigned
+gimple_acc_kernels_nparams(const_gimple gs)
+{
+  GIMPLE_CHECK (gs, GIMPLE_ACC_KERNELS);
+  return gs->gimple_acc_kernels.membase.opbase.gsbase.num_ops;
+}
+
+static inline void
+gimple_acc_kernels_set_nparams(gimple gs, unsigned nparams)
+{
+  GIMPLE_CHECK (gs, GIMPLE_ACC_KERNELS);
+  gs->gimple_acc_kernels.membase.opbase.gsbase.num_ops = nparams;
+}
+
+static inline tree*
+gimple_acc_kernels_params_ptr(gimple gs)
+{
+  GIMPLE_CHECK (gs, GIMPLE_ACC_KERNELS);
+  return gs->gimple_acc_kernels.op;
+}
+
+/* Set CHILD_FN for ACC_KERNELS GS.  */
+static inline void
+gimple_acc_kernels_set_child_fn (gimple gs, tree child_fn)
+{
+  GIMPLE_CHECK (gs, GIMPLE_ACC_KERNELS);
+  gs->gimple_acc_kernels.child_fn = child_fn;
+}
+
+/* Set CLAUSES to be associated with ACC_KERNELS GS.  */
+static inline void
+gimple_acc_kernels_set_clauses (gimple gs, tree clauses)
+{
+  GIMPLE_CHECK (gs, GIMPLE_ACC_KERNELS);
+  gs->gimple_acc_kernels.clauses = clauses;
+}
+
+/* Set DATA_ARG for ACC_KERNELS GS.  */
+//static inline void
+//gimple_acc_kernels_set_data_arg (gimple gs, tree data_arg)
+//{
+//  GIMPLE_CHECK (gs, GIMPLE_ACC_KERNELS);
+//  gs->gimple_acc_kernels.data_arg = data_arg;
+//}
+
 
 /* Returns true when the gimple statement STMT is any of the OpenMP types.  */
 
diff --git a/gcc/gimplify.c b/gcc/gimplify.c
index 1589db44b42..c083a51a244 100644
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -85,8 +85,29 @@ struct gimplify_omp_ctx
   enum omp_region_type region_type;
 };
 
+
+enum acc_region_type
+{
+  ART_PARALLEL = 1,
+  ART_COMBINED_PARALLEL = 2,
+  ART_KERNELS = 3,
+  ART_COMBINED_KERNELS = 4
+};
+
+struct gimplify_acc_ctx
+{
+  struct gimplify_acc_ctx *outer_context;
+  splay_tree variables;
+  struct pointer_set_t *privatized_types;
+  location_t location;
+  //enum acc_clause_default_kind default_kind;
+  enum acc_region_type region_type;
+};
+
+
 static struct gimplify_ctx *gimplify_ctxp;
 static struct gimplify_omp_ctx *gimplify_omp_ctxp;
+static struct gimplify_acc_ctx *gimplify_acc_ctxp;
 
 
 /* Forward declaration.  */
@@ -4717,6 +4738,15 @@ is_gimple_stmt (tree t)
     case OMP_ORDERED:
     case OMP_CRITICAL:
     case OMP_TASK:
+    case ACC_PARALLEL:
+    case ACC_KERNELS:
+    case ACC_DATA:
+    case ACC_CACHE:
+    case ACC_WAIT:
+    case ACC_HOST_DATA:
+    case ACC_LOOP:
+    case ACC_DECLARE:
+    case ACC_UPDATE:
       /* These are always void.  */
       return true;
 
@@ -7061,6 +7091,554 @@ gimplify_transaction (tree *expr_p, gimple_seq *pre_p)
   return GS_ALL_DONE;
 }
 
+
+/******************* Begin of OpenACC gimplification routines *****************/
+/******************************************************************************/
+
+static struct gimplify_acc_ctx*
+new_acc_context (enum acc_region_type region_type)
+{
+  struct gimplify_acc_ctx *c;
+
+  c = XCNEW (struct gimplify_acc_ctx);
+  c->outer_context = gimplify_acc_ctxp;
+  c->variables = splay_tree_new (splay_tree_compare_decl_uid, 0, 0);
+  c->privatized_types = pointer_set_create ();
+  c->location = input_location;
+  c->region_type = region_type;
+
+  return c;
+}
+
+static void
+delete_acc_context (struct gimplify_acc_ctx *c)
+{
+  splay_tree_delete (c->variables);
+  pointer_set_destroy (c->privatized_types);
+  XDELETE (c);
+}
+
+/* Scan the OpenACC clauses and validate for some specification rules.
+   If clause is invalid it will be removed.  */ /* TODO Fill rules */
+static void
+gimplify_scan_acc_clauses (tree *list_p, gimple_seq *pre_p,
+                           enum acc_region_type region_type)
+{
+  struct gimplify_acc_ctx *ctx, *outer_ctx;
+  struct gimplify_ctx gctx;
+  tree c;
+
+  ctx = new_acc_context (region_type);
+  outer_ctx = ctx->outer_context;
+
+  while ((c = *list_p) != NULL)
+  {
+    bool remove = false;
+    bool notice_outer = true;
+    const char *check_non_private = NULL;
+    unsigned int flags;
+    tree decl;
+/*
+    switch (ACC_CLAUSE_CODE (c))
+    {
+    case ACC_CLAUSE_ASYNC:
+      break;
+    case ACC_CLAUSE_COLLAPSE:
+      break;
+    case ACC_CLAUSE_COPY:
+      break;
+    case ACC_CLAUSE_COPYIN:
+      break;
+    case ACC_CLAUSE_COPYOUT:
+      break;
+    case ACC_CLAUSE_CREATE:
+      break;
+    case ACC_CLAUSE_DEVICE:
+      break;
+    case ACC_CLAUSE_DEVICEPTR:
+      break;
+    case ACC_CLAUSE_DEVICE_RESIDENT:
+      break;
+    case ACC_CLAUSE_FIRSTPRIVATE:
+      break;
+    case ACC_CLAUSE_GANG:
+      break;
+    case ACC_CLAUSE_HOST:
+      break;
+    case ACC_CLAUSE_IF:
+      break;
+    case ACC_CLAUSE_INDEPENDENT:
+      break;
+    case ACC_CLAUSE_NUM_GANGS:
+      break;
+    case ACC_CLAUSE_NUM_WORKERS:
+      break;
+    case ACC_CLAUSE_PRESENT:
+      break;
+    case ACC_CLAUSE_PRESENT_OR_COPY:
+      break;
+    case ACC_CLAUSE_PRESENT_OR_COPYIN:
+      break;
+    case ACC_CLAUSE_PRESENT_OR_COPYOUT:
+      break;
+    case ACC_CLAUSE_PRESENT_OR_CREATE:
+      break;
+    case ACC_CLAUSE_PRIVATE:
+      break;
+    case ACC_CLAUSE_REDUCTION:
+      break;
+    case ACC_CLAUSE_SEQ:
+      break;
+    case ACC_CLAUSE_VECTOR:
+      break;
+    case ACC_CLAUSE_VECTOR_LENGTH:
+      break;
+    case ACC_CLAUSE_WORKER:
+      break;
+    default:
+      gcc_unreachable ();
+    }
+*/
+    if (remove)
+    {
+      *list_p = ACC_CLAUSE_CHAIN (c);
+    }
+    else
+    {
+      list_p = &ACC_CLAUSE_CHAIN (c);
+    }
+  }
+
+  gimplify_acc_ctxp = ctx;
+}
+
+/* For all variables that were not actually used within the context,
+   remove PRIVATE, SHARED, and FIRSTPRIVATE clauses.  */
+/*static int
+gimplify_adjust_acc_clauses_1 (splay_tree_node n, void *data)
+{
+  tree *list_p = (tree *) data;
+  tree decl = (tree) n->key;
+  unsigned flags = n->value;
+  enum omp_clause_code code;
+  tree clause;
+  bool private_debug;
+
+  if (flags & (GOVD_EXPLICIT | GOVD_LOCAL))
+    return 0;
+  if ((flags & GOVD_SEEN) == 0)
+    return 0;
+  if (flags & GOVD_DEBUG_PRIVATE)
+    {
+      gcc_assert ((flags & GOVD_DATA_SHARE_CLASS) == GOVD_PRIVATE);
+      private_debug = true;
+    }
+  else
+    private_debug
+      = lang_hooks.decls.omp_private_debug_clause (decl,
+                                                   !!(flags & GOVD_SHARED));
+  if (private_debug)
+    code = OMP_CLAUSE_PRIVATE;
+  else if (flags & GOVD_SHARED)
+    {
+      if (is_global_var (decl))
+	{
+	  struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp->outer_context;
+	  while (ctx != NULL)
+	    {
+	      splay_tree_node on
+		= splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
+	      if (on && (on->value & (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE
+				      | GOVD_PRIVATE | GOVD_REDUCTION)) != 0)
+		break;
+	      ctx = ctx->outer_context;
+	    }
+	  if (ctx == NULL)
+	    return 0;
+	}
+      code = OMP_CLAUSE_SHARED;
+    }
+  else if (flags & GOVD_PRIVATE)
+    code = OMP_CLAUSE_PRIVATE;
+  else if (flags & GOVD_FIRSTPRIVATE)
+    code = OMP_CLAUSE_FIRSTPRIVATE;
+  else
+    gcc_unreachable ();
+
+  clause = build_omp_clause (input_location, code);
+  OMP_CLAUSE_DECL (clause) = decl;
+  OMP_CLAUSE_CHAIN (clause) = *list_p;
+  if (private_debug)
+    OMP_CLAUSE_PRIVATE_DEBUG (clause) = 1;
+  else if (code == OMP_CLAUSE_PRIVATE && (flags & GOVD_PRIVATE_OUTER_REF))
+    OMP_CLAUSE_PRIVATE_OUTER_REF (clause) = 1;
+  *list_p = clause;
+  lang_hooks.decls.omp_finish_clause (clause);
+
+  return 0;
+}*/
+
+static void
+gimplify_adjust_acc_clauses (tree *list_p)
+{
+  struct gimplify_acc_ctx *ctx = gimplify_acc_ctxp;
+  tree c, decl;
+
+  while ((c = *list_p) != NULL)
+  {
+    splay_tree_node n;
+    bool remove = false;
+
+    switch (ACC_CLAUSE_CODE (c))
+    {
+/*    case OMP_CLAUSE_PRIVATE:
+    case OMP_CLAUSE_FIRSTPRIVATE:
+      decl = OMP_CLAUSE_DECL (c);
+      n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
+      remove = !(n->value & GOVD_SEEN);
+      if (! remove)
+      {
+        bool shared = OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED;
+        if ((n->value & GOVD_DEBUG_PRIVATE)
+            || lang_hooks.decls.omp_private_debug_clause (decl, shared))
+        {
+          gcc_assert ((n->value & GOVD_DEBUG_PRIVATE) == 0
+                  || ((n->value & GOVD_DATA_SHARE_CLASS)
+              == GOVD_PRIVATE));
+          OMP_CLAUSE_SET_CODE (c, OMP_CLAUSE_PRIVATE);
+          OMP_CLAUSE_PRIVATE_DEBUG (c) = 1;
+        }
+      }
+      break;
+
+    case OMP_CLAUSE_LASTPRIVATE:
+      // Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to
+      // accurately reflect the presence of a FIRSTPRIVATE clause.
+      decl = OMP_CLAUSE_DECL (c);
+      n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
+      OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c)
+        = (n->value & GOVD_FIRSTPRIVATE) != 0;
+      break;
+*/
+    case ACC_CLAUSE_ASYNC:
+      break;
+    case ACC_CLAUSE_COLLAPSE:
+      break;
+    case ACC_CLAUSE_COPY:
+      break;
+    case ACC_CLAUSE_COPYIN:
+      break;
+    case ACC_CLAUSE_COPYOUT:
+      break;
+    case ACC_CLAUSE_CREATE:
+      break;
+    case ACC_CLAUSE_DEVICE:
+      break;
+    case ACC_CLAUSE_DEVICEPTR:
+      break;
+    case ACC_CLAUSE_DEVICE_RESIDENT:
+      break;
+    case ACC_CLAUSE_FIRSTPRIVATE:
+      break;
+    case ACC_CLAUSE_GANG:
+      break;
+    case ACC_CLAUSE_HOST:
+      break;
+    case ACC_CLAUSE_IF:
+      break;
+    case ACC_CLAUSE_INDEPENDENT:
+      break;
+    case ACC_CLAUSE_NUM_GANGS:
+      break;
+    case ACC_CLAUSE_NUM_WORKERS:
+      break;
+    case ACC_CLAUSE_PRESENT:
+      break;
+    case ACC_CLAUSE_PRESENT_OR_COPY:
+      break;
+    case ACC_CLAUSE_PRESENT_OR_COPYIN:
+      break;
+    case ACC_CLAUSE_PRESENT_OR_COPYOUT:
+      break;
+    case ACC_CLAUSE_PRESENT_OR_CREATE:
+      break;
+    case ACC_CLAUSE_PRIVATE:
+      break;
+    case ACC_CLAUSE_REDUCTION:
+      break;
+    case ACC_CLAUSE_SEQ:
+      break;
+    case ACC_CLAUSE_VECTOR:
+      break;
+    case ACC_CLAUSE_VECTOR_LENGTH:
+      break;
+    case ACC_CLAUSE_WORKER:
+      break;
+/*
+    default:
+      gcc_unreachable ();*/
+    }
+
+    if (remove)
+    {
+      *list_p = ACC_CLAUSE_CHAIN (c);
+    }
+    else
+    {
+      list_p = &ACC_CLAUSE_CHAIN (c);
+    }
+  }
+
+  /* Add in any implicit data sharing.  */
+  //splay_tree_foreach (ctx->variables, gimpliufy_adjust_acc_clauses_1, list_p);
+
+  gimplify_acc_ctxp = ctx->outer_context;
+  delete_acc_context (ctx);
+}
+
+/* Gimplify the contents of an ACC_PARALLEL statement. */
+static void
+gimplify_acc_parallel (tree *expr_p, gimple_seq *pre_p)
+{
+  tree expr = *expr_p;
+  gimple stmt;
+  gimple_seq body = NULL;
+
+  gimplify_scan_acc_clauses (&ACC_PARALLEL_CLAUSES (expr),
+                             pre_p, ART_PARALLEL);
+  gimplify_and_add (ACC_BODY (expr), &body);
+  gimplify_adjust_acc_clauses (&ACC_PARALLEL_CLAUSES (expr));
+
+  stmt = gimple_alloc (GIMPLE_ACC_PARALLEL, 0);
+
+  gimplify_seq_add_stmt (pre_p, stmt);
+}
+
+/* Gimplify the contents of an ACC_KERNELS statement. */
+static void
+gimplify_acc_kernels (tree *expr_p, gimple_seq *pre_p)
+{
+  tree expr = *expr_p;
+  gimple g;
+  gimple_seq body = NULL;
+  struct gimplify_ctx gctx;
+
+  gimplify_scan_acc_clauses (&ACC_KERNELS_CLAUSES (expr), pre_p, ART_KERNELS);
+
+  push_gimplify_context (&gctx);
+
+  g = gimplify_and_return_first (ACC_KERNELS_BODY (expr), &body);
+  if (gimple_code (g) == GIMPLE_BIND)
+    pop_gimplify_context (g);
+  else
+    pop_gimplify_context (NULL);
+
+  gimplify_adjust_acc_clauses (&ACC_KERNELS_CLAUSES (expr));
+
+  gimple p = gimple_alloc (GIMPLE_ACC_KERNELS, 0);
+  if (body)
+    p->acc.body = body;
+
+  /*g = gimple_build_acc_kernels (body,
+                                   ACC_KERNELS_CLAUSES (expr),
+                                   NULL_TREE, NULL_TREE); */
+  gimplify_seq_add_stmt (pre_p, p);
+  *expr_p = NULL_TREE;
+}
+
+/* Gimplify the contents of an ACC_DATA statement. */
+static void
+gimplify_acc_data (tree *expr_p, gimple_seq *pre_p)
+{
+  tree expr = *expr_p;
+  gimple g;
+  gimple_seq body = NULL;
+  struct gimplify_ctx gctx;
+
+  //gimplify_scan_acc_clauses (&ACC_DATA_CLAUSES (expr), pre_p, ART_DATA);
+
+  push_gimplify_context (&gctx);
+
+  //g = gimplify_and_return_first (ACC_DATA (expr), &body);
+  if (gimple_code (g) == GIMPLE_BIND)
+    pop_gimplify_context (g);
+  else
+    pop_gimplify_context (NULL);
+
+  //gimplify_adjust_acc_clauses (&ACC__CLAUSES (expr));
+
+  gimple p = gimple_alloc (GIMPLE_ACC_DATA, 0);
+
+  gimplify_seq_add_stmt (pre_p, g);
+  *expr_p = NULL_TREE;
+}
+
+/* Gimplify the contents of an ACC_HOST_DATA statement. */
+static void
+gimplify_acc_host_data (tree *expr_p, gimple_seq *pre_p)
+{
+  tree expr = *expr_p;
+  gimple g;
+  gimple_seq body = NULL;
+  struct gimplify_ctx gctx;
+
+  //gimplify_scan_acc_clauses (&ACC_HOST_DATA_CLAUSES (expr), pre_p,
+  //                           ART_HOST_DATA);
+
+  push_gimplify_context (&gctx);
+
+  //g = gimplify_and_return_first (ACC_HOST_DATA (expr), &body);
+  if (gimple_code (g) == GIMPLE_BIND)
+    pop_gimplify_context (g);
+  else
+    pop_gimplify_context (NULL);
+
+  //gimplify_adjust_acc_clauses (&ACC__CLAUSES (expr));
+
+  gimple p = gimple_alloc (GIMPLE_ACC_HOST_DATA, 0);
+
+  gimplify_seq_add_stmt (pre_p, g);
+  *expr_p = NULL_TREE;
+}
+
+/* Gimplify the contents of an ACC_LOOP statement. */
+static void
+gimplify_acc_loop (tree *expr_p, gimple_seq *pre_p)
+{
+  tree expr = *expr_p;
+  gimple g;
+  gimple_seq body = NULL;
+  struct gimplify_ctx gctx;
+
+  push_gimplify_context (&gctx);
+
+  //g = gimplify_and_return_first (ACC_LOOP (expr), &body);
+  if (gimple_code (g) == GIMPLE_BIND)
+    pop_gimplify_context (g);
+  else
+    pop_gimplify_context (NULL);
+
+  //gimplify_adjust_acc_clauses (&ACC__CLAUSES (expr));
+
+  gimple p = gimple_alloc (GIMPLE_ACC_LOOP, 0);
+  if (body)
+    p->acc.body = body;
+
+  gimplify_seq_add_stmt (pre_p, g);
+  *expr_p = NULL_TREE;
+}
+
+/* Gimplify the contents of an ACC_CACHE statement. */
+static void
+gimplify_acc_cache (tree *expr_p, gimple_seq *pre_p)
+{
+  tree expr = *expr_p;
+  gimple g;
+  gimple_seq body = NULL;
+  struct gimplify_ctx gctx;
+
+  //gimplify_scan_acc_clauses (&ACC_CACHE_CLAUSES (expr), pre_p, ART_);
+
+  push_gimplify_context (&gctx);
+
+  //g = gimplify_and_return_first (ACC_CACHE (expr), &body);
+  if (gimple_code (g) == GIMPLE_BIND)
+    pop_gimplify_context (g);
+  else
+    pop_gimplify_context (NULL);
+
+  //gimplify_adjust_acc_clauses (&ACC__CLAUSES (expr));
+
+  gimple p = gimple_alloc (GIMPLE_ACC_CACHE, 0);
+
+  gimplify_seq_add_stmt (pre_p, g);
+  *expr_p = NULL_TREE;
+}
+
+/* Gimplify the contents of an ACC_DECLARE statement. */
+static void
+gimplify_acc_declare (tree *expr_p, gimple_seq *pre_p)
+{
+  tree expr = *expr_p;
+  gimple g;
+  gimple_seq body = NULL;
+  struct gimplify_ctx gctx;
+
+  //gimplify_scan_acc_clauses (&ACC_DECLARE_CLAUSES (expr), pre_p, ART_);
+
+  push_gimplify_context (&gctx);
+
+  //g = gimplify_and_return_first (ACC_DECLARE (expr), &body);
+  if (gimple_code (g) == GIMPLE_BIND)
+    pop_gimplify_context (g);
+  else
+    pop_gimplify_context (NULL);
+
+  //gimplify_adjust_acc_clauses (&ACC__CLAUSES (expr));
+
+  gimple p = gimple_alloc (GIMPLE_ACC_DECLARE, 0);
+
+  gimplify_seq_add_stmt (pre_p, g);
+  *expr_p = NULL_TREE;
+}
+
+/* Gimplify the contents of an ACC_UPDATE statement. */
+static void
+gimplify_acc_update (tree *expr_p, gimple_seq *pre_p)
+{
+  tree expr = *expr_p;
+  gimple g;
+  gimple_seq body = NULL;
+  struct gimplify_ctx gctx;
+
+  //gimplify_scan_acc_clauses (&ACC_UPDATE_CLAUSES (expr), pre_p, ART_);
+
+  push_gimplify_context (&gctx);
+
+  //g = gimplify_and_return_first (ACC_UPDATE (expr), &body);
+  if (gimple_code (g) == GIMPLE_BIND)
+    pop_gimplify_context (g);
+  else
+    pop_gimplify_context (NULL);
+
+  //gimplify_adjust_acc_clauses (&ACC__CLAUSES (expr));
+
+  gimple p = gimple_alloc (GIMPLE_ACC_UPDATE, 0);
+
+  gimplify_seq_add_stmt (pre_p, g);
+  *expr_p = NULL_TREE;
+}
+
+/* Gimplify the contents of an ACC_WAIT statement. */
+static void
+gimplify_acc_wait (tree *expr_p, gimple_seq *pre_p)
+{
+  tree expr = *expr_p;
+  gimple g;
+  gimple_seq body = NULL;
+  struct gimplify_ctx gctx;
+
+  //gimplify_scan_acc_clauses (&ACC_WAIT_CLAUSES (expr), pre_p, ART_);
+
+  push_gimplify_context (&gctx);
+
+  //g = gimplify_and_return_first (ACC_WAIT (expr), &body);
+  if (gimple_code (g) == GIMPLE_BIND)
+    pop_gimplify_context (g);
+  else
+    pop_gimplify_context (NULL);
+
+  //gimplify_adjust_acc_clauses (&ACC__CLAUSES (expr));
+
+  gimple p = gimple_alloc (GIMPLE_ACC_WAIT, 0);
+
+  gimplify_seq_add_stmt (pre_p, g);
+  *expr_p = NULL_TREE;
+}
+
+/******************** End of OpenACC gimplification routines ******************/
+/******************************************************************************/
+
 /* Convert the GENERIC expression tree *EXPR_P to GIMPLE.  If the
    expression produces a value to be used as an operand inside a GIMPLE
    statement, the value will be stored back in *EXPR_P.  This value will
@@ -7739,6 +8317,51 @@ gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
 	  ret = GS_ALL_DONE;
 	  break;
 
+	case ACC_PARALLEL:
+	  //gimplify_acc_parallel (expr_p, pre_p);
+	  ret = GS_ALL_DONE;
+	  break;
+
+	case ACC_KERNELS:
+	  gimplify_acc_kernels (expr_p, pre_p);
+	  ret = GS_ALL_DONE;
+	  break;
+
+	case ACC_DATA:
+	  //gimplify_acc_data (expr_p, pre_p);
+	  ret = GS_ALL_DONE;
+	  break;
+
+	case ACC_HOST_DATA:
+	  //gimplify_acc_host_data (expr_p, pre_p);
+	  ret = GS_ALL_DONE;
+	  break;
+
+	case ACC_LOOP:
+	  //gimplify_acc_loop (expr_p, pre_p);
+	  ret = GS_ALL_DONE;
+	  break;
+
+	case ACC_CACHE:
+	  //gimplify_acc_cache (expr_p, pre_p);
+	  ret = GS_ALL_DONE;
+	  break;
+
+	case ACC_DECLARE:
+	  //gimplify_acc_declare (expr_p, pre_p);
+	  ret = GS_ALL_DONE;
+	  break;
+
+	case ACC_UPDATE:
+	  //gimplify_acc_update (expr_p, pre_p);
+	  ret = GS_ALL_DONE;
+	  break;
+
+	case ACC_WAIT:
+	  //gimplify_acc_wait (expr_p, pre_p);
+	  ret = GS_ALL_DONE;
+	  break;
+
 	case OMP_PARALLEL:
 	  gimplify_omp_parallel (expr_p, pre_p);
 	  ret = GS_ALL_DONE;
diff --git a/gcc/gsstruct.def b/gcc/gsstruct.def
index 91738f40950..befe3ab2457 100644
--- a/gcc/gsstruct.def
+++ b/gcc/gsstruct.def
@@ -50,4 +50,16 @@ DEFGSSTRUCT(GSS_OMP_SINGLE, gimple_statement_omp_single, false)
 DEFGSSTRUCT(GSS_OMP_CONTINUE, gimple_statement_omp_continue, false)
 DEFGSSTRUCT(GSS_OMP_ATOMIC_LOAD, gimple_statement_omp_atomic_load, false)
 DEFGSSTRUCT(GSS_OMP_ATOMIC_STORE, gimple_statement_omp_atomic_store, false)
+
+DEFGSSTRUCT(GSS_ACC, gimple_statement_acc, false)
+DEFGSSTRUCT(GSS_ACC_PARALLEL, gimple_statement_acc_parallel, false)
+DEFGSSTRUCT(GSS_ACC_KERNELS, gimple_statement_acc_kernels, true)
+DEFGSSTRUCT(GSS_ACC_DATA, gimple_statement_acc_data, false)
+DEFGSSTRUCT(GSS_ACC_CACHE, gimple_statement_acc_cache, false)
+DEFGSSTRUCT(GSS_ACC_WAIT, gimple_statement_acc_wait, false)
+DEFGSSTRUCT(GSS_ACC_HOST_DATA, gimple_statement_acc_host_data, false)
+DEFGSSTRUCT(GSS_ACC_LOOP, gimple_statement_acc_loop, false)
+DEFGSSTRUCT(GSS_ACC_DECLARE, gimple_statement_acc_declare, false)
+DEFGSSTRUCT(GSS_ACC_UPDATE, gimple_statement_acc_update, false)
+
 DEFGSSTRUCT(GSS_TRANSACTION, gimple_statement_transaction, false)
diff --git a/gcc/oacc-builtins.def b/gcc/oacc-builtins.def
new file mode 100644
index 00000000000..7573cdc0efd
--- /dev/null
+++ b/gcc/oacc-builtins.def
@@ -0,0 +1,79 @@
+/* This file contains the definitions and documentation for the
+   OpenACC builtins used in the GNU compiler.
+   Copyright (C) 2013 Free Software Foundation, Inc.
+
+   This file is part of GCC.
+
+   GCC 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 3, or (at your option) any later
+   version.
+
+   GCC 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 GCC; see the file COPYING3.  If not see
+   <http://www.gnu.org/licenses/>.  */
+
+/* Before including this file, you should define a macro:
+
+   DEF_OACC_BUILTIN (ENUM, NAME, TYPE, ATTRS)
+
+   See builtins.def for details.  */
+
+DEF_OACC_BUILTIN (BUILT_IN_OACC_GET_GLOBAL_ID, "get_global_id",
+                  BT_FN_INT_INT, ATTR_CONST_NOTHROW_LEAF_LIST)
+
+DEF_OACC_BUILTIN (BUILT_IN_OACC_CHECK_CUR_DEV, "OACC_check_cur_dev",
+                  BT_FN_VOID , ATTR_NOTHROW_LEAF_LIST)
+
+DEF_OACC_BUILTIN (BUILT_IN_OACC_GET_KERNEL, "OACC_get_kernel",
+                  BT_FN_VOIDPTR_CONST_STRING_CONST_STRING, ATTR_NOTHROW_LEAF_LIST)
+
+DEF_OACC_BUILTIN (BUILT_IN_OACC_COPYIN, "OACC_copyin",
+                  BT_FN_VOIDPTR_VOIDPTR_UNIT_INT_VOIDPTR_UINT, ATTR_NOTHROW_LEAF_LIST)
+
+DEF_OACC_BUILTIN (BUILT_IN_OACC_SET_KERNEL_ARG, "OACC_set_kernel_arg",
+                  BT_FN_VOID_VOIDPTR_UINT_VOIDPTR, ATTR_NOTHROW_LEAF_LIST)
+
+DEF_OACC_BUILTIN (BUILT_IN_OACC_START_KERNEL, "OACC_start_kernel",
+                  BT_FN_VOID_VOIDPTR_UINT_VOIDPTR_UINT, ATTR_NOTHROW_LEAF_LIST)
+
+DEF_OACC_BUILTIN (BUILT_IN_OACC_COPYOUT, "OACC_copyout",
+                  BT_FN_VOID_VOIDPTR_UNIT_INT_VOIDPTR_UINT, ATTR_NOTHROW_LEAF_LIST)
+
+DEF_OACC_BUILTIN (BUILT_IN_OACC_CREATE_EVENTS, "OACC_create_events",
+                  BT_FN_VOIDPTR_CONST_STRING_INT, ATTR_NOTHROW_LEAF_LIST)
+
+DEF_OACC_BUILTIN (BUILT_IN_OACC_ENQUEUE_EVENTS, "OACC_enqueue_events",
+                  BT_FN_VOID_VOIDPTR_UINT_INT, ATTR_NOTHROW_LEAF_LIST)
+
+DEF_OACC_BUILTIN (BUILT_IN_OACC_ADVANCE_EVENTS, "OACC_advance_events",
+                  BT_FN_VOID_VOIDPTR, ATTR_NOTHROW_LEAF_LIST)
+
+DEF_OACC_BUILTIN (BUILT_IN_OACC_WAIT_EVENTS, "OACC_wait_events",
+                  BT_FN_VOID_VOIDPTR, ATTR_NOTHROW_LEAF_LIST)
+
+DEF_OACC_BUILTIN (BUILT_IN_OACC_START_PROFILING, "OACC_start_profiling",
+                  BT_FN_VOID, ATTR_NOTHROW_LEAF_LIST)
+
+DEF_OACC_BUILTIN (BUILT_IN_OACC_CHECK_PRESENT, "OACC_check_present",
+                  BT_FN_VOIDPTR_VOIDPTR, ATTR_NOTHROW_LEAF_LIST)
+
+DEF_OACC_BUILTIN (BUILT_IN_OACC_CREATE_ON_DEVICE, "OACC_create_on_device",
+                  BT_FN_VOIDPTR_VOIDPTR_UNIT_INT_VOIDPTR_UINT, ATTR_NOTHROW_LEAF_LIST)
+
+DEF_OACC_BUILTIN (BUILT_IN_OACC_ADD_NAMED_ASYNC, "OACC_add_named_async",
+                  BT_FN_VOID_INT_VOIDPTR, ATTR_NOTHROW_LEAF_LIST)
+
+DEF_OACC_BUILTIN (BUILT_IN_OACC_ADD_NAMELESS_ASYNC, "OACC_add_nameless_async",
+                  BT_FN_VOID_VOIDPTR, ATTR_NOTHROW_LEAF_LIST)
+
+DEF_OACC_BUILTIN (BUILT_IN_OACC_WAIT_NAMED_ASYNC, "OACC_wait_named_async",
+                  BT_FN_VOID_INT, ATTR_NOTHROW_LEAF_LIST)
+
+DEF_OACC_BUILTIN (BUILT_IN_OACC_WAIT_ALL_ASYNC, "OACC_wait_all_async",
+                  BT_FN_VOID, ATTR_NOTHROW_LEAF_LIST)
diff --git a/gcc/oacc-low.c b/gcc/oacc-low.c
new file mode 100644
index 00000000000..3f2178d3e83
--- /dev/null
+++ b/gcc/oacc-low.c
@@ -0,0 +1,1781 @@
+/* 
+   This file is part of GCC.
+
+   GCC 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 3, or (at your option) any later
+   version.
+
+   GCC 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 GCC; see the file COPYING3.  If not see
+   <http://www.gnu.org/licenses/>.  */
+
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
+#include "gimple.h"
+#include "tree-inline.h"
+#include "diagnostic-core.h"
+#include "tree-flow.h"
+#include "tree-ssa.h"
+#include "expr.h"
+#include "tree-pass.h"
+#include "splay-tree.h"
+#include "cfgloop.h"
+#include "gimple-pretty-print.h"
+#include "tree-data-ref.h"
+#include "tree-scalar-evolution.h"
+#include "ssaexpand.h"
+#include "gimple-opencl.h"
+#include "diagnose-gotos.h"
+#include "input.h"
+
+#define OACC_PF_DATAIN  1
+#define OACC_PF_EXEC    2
+#define OACC_PF_DATAOUT 3
+
+/* A transformation matrix, which is a self-contained ROWSIZE x COLSIZE
+   matrix.  Rather than use floats, we simply keep a single DENOMINATOR that
+   represents the denominator for every element in the matrix.  */
+typedef struct lambda_trans_matrix_s
+{
+  lambda_matrix matrix;
+  int rowsize;
+  int colsize;
+  int denominator;
+} *lambda_trans_matrix;
+
+#define LTM_MATRIX(T) ((T)->matrix)
+#define LTM_ROWSIZE(T) ((T)->rowsize)
+#define LTM_COLSIZE(T) ((T)->colsize)
+#define LTM_DENOMINATOR(T) ((T)->denominator)
+
+/* Allocate a new transformation matrix.  */
+
+static lambda_trans_matrix
+lambda_trans_matrix_new (int colsize, int rowsize,
+                         struct obstack *lambda_obstack)
+{
+  lambda_trans_matrix ret;
+
+  ret = (lambda_trans_matrix)
+    obstack_alloc (lambda_obstack,
+                   sizeof (struct lambda_trans_matrix_s));
+  LTM_MATRIX (ret) = lambda_matrix_new (rowsize,
+                                        colsize,
+                                        lambda_obstack);
+  LTM_ROWSIZE (ret) = rowsize;
+  LTM_COLSIZE (ret) = colsize;
+  LTM_DENOMINATOR (ret) = 1;
+  return ret;
+}
+/* Multiply a vector VEC by a matrix MAT.
+   MAT is an M*N matrix, and VEC is a vector with length N.  The result
+   is stored in DEST which must be a vector of length M.  */
+
+static void
+lambda_matrix_vector_mult (lambda_matrix matrix, int m, int n,
+                           lambda_vector vec, lambda_vector dest)
+{
+  int i, j;
+
+  lambda_vector_clear (dest, m);
+  for (i = 0; i < m; i++)
+    for (j = 0; j < n; j++)
+      dest[i] += matrix[i][j] * vec[j];
+}
+
+/* Return true if TRANS is a legal transformation matrix that respects
+   the dependence vectors in DISTS and DIRS.  The conservative answer
+   is false.
+
+   "Wolfe proves that a unimodular transformation represented by the
+   matrix T is legal when applied to a loop nest with a set of
+   lexicographically non-negative distance vectors RDG if and only if
+   for each vector d in RDG, (T.d >= 0) is lexicographically positive.
+   i.e.: if and only if it transforms the lexicographically positive
+   distance vectors to lexicographically positive vectors.  Note that
+   a unimodular matrix must transform the zero vector (and only it) to
+   the zero vector." S.Muchnick.  */
+
+static bool
+lambda_transform_legal_p (lambda_trans_matrix trans,
+                          int nb_loops,
+                          vec<ddr_p> dependence_relations)
+{
+  unsigned int i, j;
+  lambda_vector distres;
+  struct data_dependence_relation *ddr;
+
+  gcc_assert (LTM_COLSIZE (trans) == nb_loops
+              && LTM_ROWSIZE (trans) == nb_loops);
+
+  /* When there are no dependences, the transformation is correct.  */
+  if (dependence_relations.length () == 0)
+    return true;
+
+  ddr = dependence_relations[0];
+  if (ddr == NULL)
+    return true;
+
+  /* When there is an unknown relation in the dependence_relations, we
+     know that it is no worth looking at this loop nest: give up.  */
+  if (DDR_ARE_DEPENDENT (ddr) == chrec_dont_know)
+    return false;
+
+  distres = lambda_vector_new (nb_loops);
+
+  /* For each distance vector in the dependence graph.  */
+  FOR_EACH_VEC_ELT (dependence_relations, i, ddr)
+    {
+      /* Don't care about relations for which we know that there is no
+         dependence, nor about read-read (aka. output-dependences):
+         these data accesses can happen in any order.  */
+      if (DDR_ARE_DEPENDENT (ddr) == chrec_known
+          || (DR_IS_READ (DDR_A (ddr)) && DR_IS_READ (DDR_B (ddr))))
+         continue;
+
+      /* Conservatively answer: "this transformation is not valid".  */
+      if (DDR_ARE_DEPENDENT (ddr) == chrec_dont_know)
+        return false;
+
+      /* If the dependence could not be captured by a distance vector,
+         conservatively answer that the transform is not valid.  */
+      if (DDR_NUM_DIST_VECTS (ddr) == 0)
+        return false;
+
+      /* Compute trans.dist_vect */
+      for (j = 0; j < DDR_NUM_DIST_VECTS (ddr); j++)
+        {
+          lambda_matrix_vector_mult (LTM_MATRIX (trans), nb_loops, nb_loops,
+                                     DDR_DIST_VECT (ddr, j), distres);
+
+          if (!lambda_vector_lexico_pos (distres, nb_loops))
+            return false;
+        }
+    }
+  return true;
+}
+
+static GTY(()) char *ocl_module;
+
+static GTY(()) bitmap oacc_kernels;
+
+typedef struct oacc_context {
+    /* This field must be at the beginning, as we do "inheritance": Some
+       callback functions for tree-inline.c (e.g., omp_copy_decl)
+       receive a copy_body_data pointer that is up-casted to an
+       omp_context pointer.  */
+    copy_body_data cb;
+
+    /* The tree of contexts corresponding to the encountered constructs.  */
+    struct oacc_context *outer;
+    gimple stmt;
+
+    splay_tree param_map;
+    splay_tree local_map;
+    /* Nesting depth of this context.  Used to beautify error messages re
+       invalid gotos.  The outermost ctx is depth 1, with depth 0 being
+       reserved for the main body of the function.  */
+    int depth;
+
+    /* True if this parallel directive is nested within another.  */
+    bool is_nested;
+} oacc_context;
+
+static splay_tree all_contexts;
+static int nesting_level;
+
+static void analyze_gimple(gimple_seq* pseq, oacc_context* ctx);
+static void lower_oacc(gimple_seq* pseq, oacc_context* ctx);
+
+static oacc_context*
+new_oacc_context(gimple stmt, oacc_context* outer)
+{
+  oacc_context *ctx = XCNEW(oacc_context);
+  splay_tree_insert(all_contexts, (splay_tree_key)stmt, (splay_tree_value)ctx);
+  ctx->stmt = stmt;
+
+  if(outer) {
+      ctx->outer = outer;
+      ctx->cb = outer->cb;
+      ctx->cb.block = NULL;
+      ctx->depth = outer->depth+1;
+  }
+  else {
+      ctx->cb.src_fn = current_function_decl;
+      ctx->cb.dst_fn = current_function_decl;
+      ctx->cb.src_node = cgraph_get_node (current_function_decl);
+      gcc_checking_assert (ctx->cb.src_node);
+      ctx->cb.dst_node = ctx->cb.src_node;
+      ctx->cb.src_cfun = cfun;
+      ctx->cb.eh_lp_nr = 0;
+      ctx->cb.transform_call_graph_edges = CB_CGE_MOVE;
+      ctx->depth = 1;
+  }
+  ctx->cb.decl_map = pointer_map_create();
+  return ctx;
+}
+
+static void
+delete_oacc_context(splay_tree_value value)
+{
+  oacc_context *ctx = (oacc_context *) value;
+
+  if(ctx->param_map)
+    splay_tree_delete(ctx->param_map);
+  if(ctx->local_map)
+    splay_tree_delete(ctx->local_map);
+  XDELETE(ctx);
+}
+
+static int
+add_local_to_bind(splay_tree_node n, void* data)
+{
+  gimple stmt = (gimple)data;
+  gimple_bind_append_vars(stmt, (tree)n->value);
+  return 0;
+}
+
+static int
+add_assign_to_bind(splay_tree_node n, void* data)
+{
+  gimple_seq* assigns = (gimple_seq*)data;
+  gimple stmt;
+
+  stmt = gimple_build_assign((tree)n->value, (tree)n->key);
+  gimple_seq_add_stmt(assigns, stmt);
+  return 0;
+}
+
+static void add_locals_to_bind(gimple bind, oacc_context* ctx)
+{
+  gimple_seq bind_body = gimple_bind_body(bind), assigns = NULL;
+  splay_tree_foreach(ctx->local_map, add_local_to_bind, (void*)bind);
+  /*
+     splay_tree_foreach(ctx->local_map, add_assign_to_bind, (void*)&assigns);
+     if(assigns != NULL) {
+     gimple_seq_add_seq(&assigns, bind_body);
+     gimple_bind_set_body(bind, assigns);
+     }
+   */
+}
+
+static void add_locals(gimple_seq* pbody, oacc_context* ctx)
+{
+  if(gimple_code(gimple_seq_first(*pbody)) == GIMPLE_BIND) {
+      add_locals_to_bind(gimple_seq_first(*pbody), ctx);
+  }
+}
+
+static int
+create_call_params(splay_tree_node node, void* data)
+{
+  vec<tree>* pargs = (vec<tree>*)data;
+  if((tree)node->value != NULL_TREE) {
+      pargs->quick_push((tree)node->key);
+  }
+  return 0;
+}
+
+static void
+lower_oacc_kernels(gimple_stmt_iterator *gsi, oacc_context* ctx)
+{
+  struct function *child_cfun;
+  tree child_fn;
+  gimple stmt = gsi_stmt (*gsi), call_stmt;
+  gimple_seq* pbody;
+  int i;
+
+  pbody = gimple_acc_body_ptr(stmt);
+  lower_oacc(pbody, ctx);
+  child_fn = gimple_acc_kernels_child_fn(stmt);
+
+  add_locals(pbody, ctx);
+  gimple_set_body(child_fn, *pbody);
+
+  child_cfun = DECL_STRUCT_FUNCTION (child_fn);
+  DECL_STRUCT_FUNCTION (child_fn)->curr_properties = cfun->curr_properties;
+  cgraph_add_new_function (child_fn, false);
+
+  vec<tree> args;
+  args.create(16);
+  splay_tree_foreach(ctx->param_map, create_call_params, (void*)&args);
+  size_t size = sizeof(struct gimple_statement_acc_kernels) + (args.length() - 1) * sizeof(tree);
+  gimple new_stmt = ggc_alloc_gimple_statement_d (size);
+  memcpy(new_stmt, stmt, sizeof(struct gimple_statement_acc_kernels));
+
+  gimple_set_num_ops(new_stmt, args.length());
+  for(i = 0; i < args.length(); ++i) {
+      tree arg = args[i];
+      if(dump_file) {
+          fprintf(dump_file, "argument ");
+          print_generic_expr(dump_file, arg, 0);
+          fprintf(dump_file, " type ");
+          print_generic_expr(dump_file, TREE_TYPE(arg), 0);
+          fprintf(dump_file, "\n");
+      }
+      gimple_set_op(new_stmt, i, arg);
+  }
+
+  gimple_acc_set_body(new_stmt, NULL);
+  gsi_replace(gsi, new_stmt, false);
+}
+
+static tree
+lower_stmt_cb(gimple_stmt_iterator *gsi, bool *handled_ops_p, struct walk_stmt_info *wi)
+{
+  gimple stmt = gsi_stmt (*gsi);
+  oacc_context *ctx = (oacc_context *) wi->info;
+
+  *handled_ops_p = true;
+
+  switch (gimple_code (stmt))
+    {
+    case GIMPLE_ACC_KERNELS:
+      ctx = (oacc_context*)splay_tree_lookup(all_contexts, (splay_tree_key)stmt)->value;
+      lower_oacc_kernels (gsi, ctx);
+      break;
+
+    default:
+      *handled_ops_p = false;
+      break;
+    }
+  return NULL_TREE;
+}
+
+static tree
+lower_op_cb(tree *tp, int *walk_subtrees, void *data)
+{
+  struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
+  oacc_context* ctx = (oacc_context*)wi->info;
+  tree t = *tp;
+
+  if(ctx != 0 && is_gimple_variable(t)) {
+      tree t1 = NULL_TREE;
+      splay_tree_node v = splay_tree_lookup(ctx->param_map, (splay_tree_key)t);
+      if(v) {
+          t1 = (tree)v->value;
+          if(t1 == NULL_TREE) {
+              v = splay_tree_lookup(ctx->local_map, (splay_tree_key)t);
+              t1 = (tree)v->value;
+          }
+          *tp = t1;
+          if(dump_file) {
+              fprintf(dump_file, "Subst ");
+              print_generic_expr(dump_file, t, 0);
+              fprintf(dump_file, " with ");
+              print_generic_expr(dump_file, t1, 0);
+              fprintf(dump_file, "\n");
+          }
+      }
+  }
+  else if(ctx != 0 && TREE_CODE(t) == LABEL_DECL) {
+      DECL_CONTEXT(t) = ctx->cb.dst_fn;
+  }
+  return NULL_TREE;
+}
+
+static void
+lower_oacc(gimple_seq* pseq, oacc_context* ctx)
+{
+  struct walk_stmt_info wi;
+
+  memset (&wi, 0, sizeof (wi));
+  wi.info = ctx;
+
+  walk_gimple_seq_mod (pseq, lower_stmt_cb, lower_op_cb, &wi);
+}
+
+static int
+gather_oacc_fn_args(splay_tree_node node, void* data)
+{
+  vec<tree>* pargs = (vec<tree>*)data;
+  tree arg = (tree)node->key;
+  if(!is_gimple_reg(arg)) {
+      pargs->quick_push(arg);
+  }
+  else {
+      node->value = (splay_tree_value)NULL_TREE;
+  }
+  return 0;
+}
+
+static tree
+normalize_name(tree name)
+{
+  char *normal, *pn;
+  const char *ptr;
+
+  normal = XALLOCAVEC(char, IDENTIFIER_LENGTH(name) + 1);
+  pn = normal;
+  for(ptr = IDENTIFIER_POINTER(name); *ptr != '\0'; ++ptr) {
+      if(*ptr == '.' || *ptr == '$') {
+          *pn++ = '_';
+      }
+      else {
+          *pn++ = *ptr;
+      }
+  }
+  *pn = '\0';
+  return get_identifier(normal);
+}
+
+static int
+gather_oacc_fn_locals(splay_tree_node node, void* data)
+{
+  splay_tree* local_map = (splay_tree*)data;
+  tree arg = (tree)node->key;
+  if(is_gimple_reg(arg)) {
+      const char *id = "_oacc_param";
+      if(DECL_NAME(arg)) {
+          id = IDENTIFIER_POINTER(DECL_NAME(arg));
+      }
+      tree t1 = create_tmp_reg(TREE_TYPE(arg), id);
+      splay_tree_insert(*local_map, (splay_tree_key)arg, (splay_tree_value)t1);
+      if(dump_file) {
+          fprintf(dump_file, "Create local reg for: ");
+          print_generic_expr(dump_file, arg, 0);
+          fprintf(dump_file, " reg:");
+          print_generic_expr(dump_file, t1, 0);
+          fprintf(dump_file, "\n");
+      }
+  }
+  return 0;
+}
+
+static int
+fix_decl_context(splay_tree_node node, void* data)
+{
+  tree decl = (tree)data;
+  tree loc = (tree)node->value;
+  DECL_CONTEXT(loc) = decl;
+  return 0;
+}
+
+static void
+create_oacc_child_function(oacc_context* ctx)
+{
+  tree name, type, decl, t, t1;
+  vec<tree> args, types;
+  unsigned i;
+
+  name = clone_function_name(current_function_decl, "_oacc_fn");
+  name = normalize_name(name);
+  if(dump_file) {
+      fprintf(dump_file, "new fn name='%s'\n", IDENTIFIER_POINTER(name));
+  }
+
+  args.create(16);
+  splay_tree_foreach(ctx->param_map, gather_oacc_fn_args, (void*)&args);
+  types.create(16);
+  for(i = 0; i < args.length(); ++i) {
+      tree type = TREE_TYPE(args[i]);
+      if(dump_file) {
+          fprintf(dump_file, "Create parameter type: ");
+          print_generic_expr(dump_file, args[i], 0);
+          fprintf(dump_file, " type=");
+          print_generic_expr(dump_file, type, 0);
+          fprintf(dump_file, "\n");
+      }
+      types.quick_push(type);
+  }
+  type = build_function_type_array(void_type_node, types.length(), types.address());
+  decl = build_decl(gimple_location(ctx->stmt), FUNCTION_DECL, name, type);
+  ctx->cb.dst_fn = decl;
+
+  TREE_STATIC (decl) = 1;
+  TREE_USED (decl) = 1;
+  DECL_ARTIFICIAL (decl) = 1;
+  DECL_NAMELESS (decl) = 1;
+  DECL_IGNORED_P (decl) = 0;
+  TREE_PUBLIC (decl) = 0;
+  DECL_UNINLINABLE (decl) = 1;
+  DECL_EXTERNAL (decl) = 0;
+  DECL_CONTEXT (decl) = NULL_TREE;
+  DECL_INITIAL (decl) = make_node (BLOCK);
+
+  t = build_decl (DECL_SOURCE_LOCATION (decl),
+                  RESULT_DECL, NULL_TREE, void_type_node);
+  DECL_ARTIFICIAL (t) = 1;
+  DECL_IGNORED_P (t) = 1;
+  DECL_CONTEXT (t) = decl;
+  DECL_RESULT (decl) = t;
+
+  for(i = args.length(); i > 0; --i) {
+      const char *id = "_oacc_param";
+      if(DECL_NAME(args[i-1])) {
+          id = IDENTIFIER_POINTER(DECL_NAME(args[i-1]));
+      }
+      t = build_decl(DECL_SOURCE_LOCATION (decl), PARM_DECL, create_tmp_var_name(id), types[i-1]);
+      if(dump_file) {
+          fprintf(dump_file, "Create formal param: ");
+          print_generic_expr(dump_file, t, 0);
+          fprintf(dump_file, " type=");
+          print_generic_expr(dump_file, types[i-1], 0);
+          fprintf(dump_file, "\n");
+      }
+
+      DECL_ARTIFICIAL (t) = 1;
+      DECL_NAMELESS (t) = 1;
+      DECL_ARG_TYPE (t) = types[i-1];
+      DECL_CONTEXT(t) = decl;
+      TREE_USED (t) = 1;
+      TREE_ADDRESSABLE (t) = 1;
+      if(i > 0)
+        DECL_CHAIN (t) = DECL_ARGUMENTS (decl);
+      DECL_ARGUMENTS (decl) = t;
+      splay_tree_lookup(ctx->param_map, (splay_tree_key)args[i-1])->value = (splay_tree_value)t;
+  }
+
+  splay_tree_foreach(ctx->param_map, gather_oacc_fn_locals, (void*)&ctx->local_map);
+  splay_tree_foreach(ctx->local_map, fix_decl_context, (void*)decl);
+
+  /* Allocate memory for the function structure.  The call to
+     allocate_struct_function clobbers CFUN, so we need to restore
+     it afterward.  */
+  push_struct_function (decl);
+  cfun->function_end_locus = gimple_location (ctx->stmt);
+  pop_cfun ();
+}
+
+static void
+scan_oacc_kernels (gimple_stmt_iterator *gsi, oacc_context *outer_ctx)
+{
+  struct function *child_cfun;
+  tree child_fn;
+  oacc_context* ctx;
+  gimple stmt = gsi_stmt (*gsi);
+  location_t loc = gimple_location (stmt);
+
+  /* Ignore task directives with empty bodies.  */
+  if (optimize > 0
+      && empty_body_p (gimple_acc_body (stmt)))
+    {
+      gsi_replace (gsi, gimple_build_nop (), false);
+      return;
+    }
+
+  ctx = new_oacc_context (stmt, outer_ctx);
+  if (nesting_level > 1)
+    ctx->is_nested = true;
+  ctx->param_map = splay_tree_new (splay_tree_compare_pointers, 0, 0);
+  ctx->local_map = splay_tree_new (splay_tree_compare_pointers, 0, 0);
+
+  analyze_gimple(gimple_acc_body_ptr(stmt), ctx);
+  create_oacc_child_function(ctx);
+
+  child_fn = ctx->cb.dst_fn;
+  gimple_acc_kernels_set_child_fn(stmt, child_fn);
+
+}
+
+static bool
+check_oacc_nesting_restrictions (gimple stmt, oacc_context *ctx)
+{
+  // TODO
+  return true;
+}
+
+static tree
+analyze_stmt_cb(gimple_stmt_iterator *gsi, bool *handled_ops_p, struct walk_stmt_info *wi)
+{
+  gimple stmt = gsi_stmt (*gsi);
+  oacc_context *ctx = (oacc_context *) wi->info;
+
+  if (gimple_has_location (stmt))
+    input_location = gimple_location (stmt);
+
+  /* Check the OpenACC nesting restrictions.  */
+  if (ctx != NULL) {
+      bool remove = false;
+      if (is_gimple_acc (stmt))
+        remove = !check_oacc_nesting_restrictions (stmt, ctx);
+      if (remove) {
+          stmt = gimple_build_nop ();
+          gsi_replace (gsi, stmt, false);
+      }
+  }
+
+  *handled_ops_p = true;
+
+  switch (gimple_code (stmt))
+    {
+    case GIMPLE_ACC_KERNELS:
+      nesting_level++;
+      scan_oacc_kernels (gsi, ctx);
+      nesting_level--;
+      break;
+
+    case GIMPLE_BIND:
+        {
+          tree var;
+
+          *handled_ops_p = false;
+          if (ctx)
+            for (var = gimple_bind_vars (stmt); var ; var = DECL_CHAIN (var))
+              insert_decl_map (&ctx->cb, var, var);
+        }
+      break;
+    default:
+      *handled_ops_p = false;
+      break;
+    }
+  return NULL_TREE;
+}
+
+static tree
+analyze_op_cb(tree *tp, int *walk_subtrees, void *data)
+{
+  struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
+  oacc_context* ctx = (oacc_context*)wi->info;
+  tree t = *tp;
+
+  if(ctx != 0 && is_gimple_variable(t)) {
+      tree* n = (tree *) pointer_map_contains (ctx->cb.decl_map, t);
+      if(!n) {
+          splay_tree_node v = splay_tree_lookup(ctx->param_map, (splay_tree_key)t);
+          if(!v) {
+              splay_tree_insert(ctx->param_map, (splay_tree_key)t, (splay_tree_value)t);
+          }
+      }
+  }
+
+  return NULL_TREE;
+}
+
+static void
+analyze_gimple(gimple_seq* pseq, oacc_context* ctx)
+{
+  location_t saved_location;
+  struct walk_stmt_info wi;
+
+  memset (&wi, 0, sizeof (wi));
+  wi.info = ctx;
+  wi.want_locations = true;
+
+  saved_location = input_location;
+  walk_gimple_seq_mod (pseq, analyze_stmt_cb, analyze_op_cb, &wi);
+  input_location = saved_location;
+}
+
+static char*
+generate_ocl_module_name(void)
+{
+  size_t filename_len = strlen(main_input_filename);
+  char* cur_module = XNEWVEC(char, filename_len + 4);
+  const char* slash_ptr = strrchr(main_input_filename, '/');
+  const char* dot_ptr = strrchr(main_input_filename, '.');
+  if(dot_ptr && (!slash_ptr || dot_ptr > slash_ptr)) {
+      int cpy_len = filename_len - strlen(dot_ptr) + 1;
+      memcpy(cur_module, main_input_filename, cpy_len);
+      cur_module[cpy_len] = '\0';
+  }
+  else {
+      strcpy(cur_module, main_input_filename);
+      strcpy(cur_module, ".");
+  }
+  strcat(cur_module, "cl");
+  return cur_module;
+}
+
+static bool
+switch_ocl_module(char* cur_module)
+{
+  if(ocl_module == NULL || strcmp(ocl_module, cur_module) != 0) {
+      if(access(cur_module, 0) == 0) {
+          unlink(cur_module);
+      }
+
+      if(ocl_module) ggc_free(ocl_module);
+      ocl_module = (char*)ggc_strdup(cur_module);
+
+      return true;
+  }
+
+  return false;
+}
+
+/* Main entry point for lowering OpenACC.  */
+static unsigned int
+execute_lower_oacc (void)
+{
+  gimple_seq func_body = 0;
+
+  char* cur_module = generate_ocl_module_name();
+  if(switch_ocl_module(cur_module)) {
+      if(dump_file) {
+          fprintf(dump_file, "main module: '%s', opencl module: '%s'\n", main_input_filename, ocl_module);
+      }
+  }
+  XDELETEVEC(cur_module);
+
+
+  all_contexts = splay_tree_new(splay_tree_compare_pointers, 0, delete_oacc_context);
+  func_body = gimple_body(current_function_decl);
+  nesting_level = 0;
+  analyze_gimple(&func_body, NULL);
+  gcc_assert(nesting_level == 0);
+
+  if(all_contexts->root) {
+      struct gimplify_ctx gctx;
+      push_gimplify_context(&gctx);
+      lower_oacc(&func_body, NULL);
+      pop_gimplify_context(NULL);
+  }
+
+  if(all_contexts) {
+      splay_tree_delete(all_contexts);
+      all_contexts = NULL;
+  }
+
+
+  return 0;
+}
+
+/* OpenACC lowering gate */
+
+static bool
+gate_lower_oacc (void)
+{
+  return (flag_openacc != 0);
+}
+
+namespace {
+const pass_data pass_data_lower_oacc =
+{
+      GIMPLE_PASS,
+      "oacclow",				/* name */
+      OPTGROUP_NONE,                        /* optinfo_flags */
+      gate_lower_oacc,			/* gate */
+      execute_lower_oacc,			/* execute */
+      TV_NONE,				/* tv_id */
+      PROP_gimple_any,			/* properties_required */
+      0,					/* properties_provided */
+      0,					/* properties_destroyed */
+      0,					/* todo_flags_start */
+      0                      		/* todo_flags_finish */
+};
+
+class pass_lower_oacc : public gimple_opt_pass
+{
+public:
+  pass_lower_oacc(gcc::context *ctxt)
+    :
+      gimple_opt_pass(pass_data_lower_oacc,
+                      ctxt)
+  {}
+
+  /* opt_pass methods: */
+  bool gate ()
+    {
+      return gate_lower_oacc();
+    }
+  unsigned int execute ()
+    {
+      return execute_lower_oacc ();
+    }
+};
+
+}
+
+gimple_opt_pass *
+make_pass_lower_oacc (gcc::context *ctxt)
+{
+  return new pass_lower_oacc (ctxt);
+}
+
+static gimple
+build_call(location_t locus, tree funcdecl, int n, ...)
+{
+  va_list ap;
+  int i;
+  tree* args = XALLOCAVEC(tree, n);
+
+  va_start(ap, n);
+  for(i = 0; i < n; ++i) {
+      args[i] = va_arg(ap, tree);
+  }
+  va_end(ap);
+
+  return gimple_build_call_from_tree(build_call_expr_loc_array(locus, funcdecl, n, args));
+}
+
+inline static void
+gen_replace(gimple_stmt_iterator* gsi, gimple stmt)
+{
+  gsi_replace(gsi, stmt, true);
+}
+
+inline static void
+gen_add(gimple_stmt_iterator* gsi, gimple stmt)
+{
+  gsi_insert_after(gsi, stmt, GSI_NEW_STMT);
+}
+
+static bool
+loop_precheck(struct loop* l)
+{
+  if(!single_dom_exit(l)) {
+      if(dump_file) {
+          fprintf(dump_file, " !single_dom_exit\n");
+      }
+      return false;
+  }
+  return true;
+}
+
+static bool
+loop_parallelizable(struct loop* l, struct obstack* pobstack)
+{
+  vec<loop_p> loop_nest;
+  vec<ddr_p> dependence_relations;
+  vec<data_reference_p> datarefs;
+  lambda_trans_matrix trans;
+  bool ret = false;
+
+  /* Check for problems with dependences.  If the loop can be reversed,
+     the iterations are independent.  */
+  datarefs.create (10);
+  dependence_relations.create (10 * 10);
+  loop_nest.create (3);
+  if(dump_file) fprintf(dump_file, "compute data dependences\n");
+
+  if (! compute_data_dependences_for_loop (l, true, &loop_nest, &datarefs,
+                                           &dependence_relations))
+    {
+      if (dump_file /*&& (dump_flags & TDF_DETAILS)*/)
+        fprintf (dump_file, "  FAILED: cannot analyze data dependencies\n");
+      ret = false;
+      goto end;
+    }
+
+
+  if (dump_file /*&& (dump_flags & TDF_DETAILS)*/) {
+      fprintf(dump_file, "loop_nest %d, ddr %d, datarefs %d\n", loop_nest.length(), dependence_relations.length(), datarefs.length());
+      dump_data_dependence_relations (dump_file, dependence_relations);
+  }
+
+  trans = lambda_trans_matrix_new (1, 1, pobstack);
+  LTM_MATRIX (trans)[0][0] = -1;
+
+  if(dump_file) fprintf(dump_file, "lambda transform legal\n");
+  if (lambda_transform_legal_p (trans, 1, dependence_relations))
+    {
+      ret = true;
+      if (dump_file /*&& (dump_flags & TDF_DETAILS)*/)
+        fprintf (dump_file, "  SUCCESS: may be parallelized\n");
+    }
+  else if (dump_file /*&& (dump_flags & TDF_DETAILS)*/)
+    fprintf (dump_file,
+             "  FAILED: data dependencies exist across iterations\n");
+
+end:
+  loop_nest.release ();
+  free_dependence_relations (dependence_relations);
+  free_data_refs (datarefs);
+  return ret;
+}
+
+static bool
+loops_parallelizable_p(struct loop* root,	struct tree_niter_desc* pniter_desc)
+{
+  if(root->inner == NULL) {
+      return true;
+  }
+  if(dump_file) {
+      fprintf(dump_file, "Testing loop dependencies\n");
+  }
+  struct loop* ploop;
+  struct obstack oacc_obstack;
+  bool ret = true;
+
+  gcc_obstack_init (&oacc_obstack);
+  for(ploop = root->inner; ploop != NULL; ploop = ploop->next) {
+      if(dump_file) {
+          fprintf(dump_file, "loop %d\n", ploop->num);
+      }
+      if(!loop_precheck(ploop)) {
+          ret = false;
+          break;
+      }
+
+      /*
+         Works under cygwin, DOESN'T work under Linux (???)
+       */
+      if(!loop_parallelizable(ploop, &oacc_obstack)) {
+          ret = false;
+          break;
+      }
+
+      if(ret) {
+
+          estimate_numbers_of_iterations_loop(ploop);
+          HOST_WIDE_INT estimated;
+          estimated = estimated_stmt_executions_int (ploop);
+          if (estimated == -1)
+            estimated = max_stmt_executions_int (ploop);
+          if (dump_file)
+            fprintf (dump_file, "Estimated # of iterations %lld\n", estimated);
+
+          edge exit = single_dom_exit (ploop);
+
+          gcc_assert (exit);
+
+          if (!number_of_iterations_exit (ploop, exit, pniter_desc, false))
+            {
+              if(estimated != -1) {
+                  pniter_desc->niter = build_int_cst(uint32_type_node, estimated);
+              }
+              else {
+                  if (dump_file)
+                    fprintf (dump_file, "  FAILED: number of iterations not known\n");
+                  ret = false;
+              }
+            }
+          else {
+              if(dump_file) {
+                  fprintf(dump_file, "niter: ");
+                  print_generic_expr(dump_file, pniter_desc->niter, 0);
+                  fprintf(dump_file, "\n");
+                  fprintf(dump_file, "max: %lld\n", pniter_desc->max.to_shwi());
+              }
+          }
+      }
+  }
+  obstack_free (&oacc_obstack, NULL);
+
+
+  return ret;
+}
+
+static tree
+get_gimple_def_var(gimple stmt)
+{
+  tree var = NULL_TREE;
+  gcc_assert(gimple_code(stmt) == GIMPLE_ASSIGN || gimple_code(stmt) == GIMPLE_CALL || gimple_code(stmt) == GIMPLE_PHI);
+
+  if(gimple_code(stmt) == GIMPLE_PHI) {
+      var = gimple_phi_result(stmt);
+  }
+  else if(is_gimple_assign(stmt)) {
+      var = gimple_assign_lhs(stmt);
+  }
+  else {
+      var = gimple_call_lhs(stmt);
+  }
+  return var;
+}
+
+static void
+set_gimple_def_var(gimple stmt, tree var)
+{
+  gcc_assert(gimple_code(stmt) == GIMPLE_ASSIGN || gimple_code(stmt) == GIMPLE_CALL);
+
+  if(is_gimple_assign(stmt)) {
+      gimple_assign_set_lhs(stmt, var);
+  }
+  else {
+      gimple_call_set_lhs(stmt, var);
+  }
+}
+
+static tree check_for_ctrl_var(tree);
+
+static bool
+check_for_ctrl_var_cb(tree var, gimple stmt, void* data)
+{
+  tree* pvar = (tree*)data;
+  unsigned i;
+
+  for(i = 0; i < gimple_num_ops(stmt); ++i) {
+      tree op_var = gimple_op(stmt, i);
+      if(op_var == var) {
+          continue;
+      }
+      op_var = check_for_ctrl_var(op_var);
+      if(op_var != NULL_TREE) {
+          *pvar = op_var;
+          return true;
+      }
+  }
+  return false;
+}
+
+static tree
+check_for_ctrl_var(tree var)
+{
+  if(dump_file) {
+      fprintf(dump_file, "check var ");
+      print_generic_expr(dump_file, var, 0);
+      fprintf(dump_file, "\n");
+  }
+  if(is_gimple_constant(var)) {
+      return NULL_TREE;
+  }
+
+  if(is_gimple_variable(var)) {
+      if(SSA_NAME_VAR(var)) {
+          return var;
+      }	
+      else {
+          tree new_var = NULL_TREE;
+          walk_use_def_chains(var, check_for_ctrl_var_cb, (void*)&new_var, false);
+
+          if(new_var != NULL_TREE) {
+              return new_var;
+          }
+      }
+  }
+
+  return NULL_TREE;
+}
+
+
+// TODO
+// check for those have cycle in SSA graph (?)
+static tree
+find_ctrl_var(basic_block header)
+{
+  gimple cond_stmt;
+  tree var = NULL_TREE;
+
+  cond_stmt = gsi_stmt(gsi_last_bb(header));
+
+  gcc_assert(gimple_code(cond_stmt) == GIMPLE_COND);
+
+  var = check_for_ctrl_var(gimple_cond_lhs(cond_stmt));
+  if(var != NULL_TREE) {
+      return var;
+  }
+
+  var = check_for_ctrl_var(gimple_cond_rhs(cond_stmt));
+  gcc_assert(var != NULL_TREE);
+  return var;
+}
+
+static bool
+ud_chain_cb(tree var, gimple stmt, void* data)
+{
+  if(dump_file) {
+      fprintf(dump_file, "walk ud chain ");
+      print_generic_expr(dump_file, var, 0);
+      fprintf(dump_file, " ");
+      print_gimple_stmt(dump_file, stmt, 0, 0);
+      fprintf(dump_file, "\n");
+  }
+  if(gimple_code(stmt) != GIMPLE_PHI) {
+      gimple* pstmt = (gimple*)data;
+      *pstmt = stmt;
+      return true;
+  }
+
+  return false;
+}
+
+static void
+find_ctrl_var_init(tree var, gimple_stmt_iterator* gsi)
+{
+  gimple def_stmt;
+  walk_use_def_chains(var, ud_chain_cb, (void*)&def_stmt, false);
+  *gsi = gsi_for_stmt(def_stmt);
+  while(!gsi_end_p(*gsi)) {
+      if(gsi_stmt(*gsi) == def_stmt) {
+          return;
+      }
+      gsi_next(gsi);
+  }
+}
+
+static bool
+ctrl_var_cb(tree var, gimple stmt, void* data)
+{
+  vec<gimple_stmt_iterator>* piter = (vec<gimple_stmt_iterator>*)data;
+  gimple_stmt_iterator gsi = gsi_for_stmt(stmt);
+  while(!gsi_end_p(gsi))
+    {
+      if(gsi_stmt(gsi) == stmt)
+        {
+          if(gimple_code (stmt) == GIMPLE_PHI)
+            {
+              int i;
+              for(i = 0; i < piter->length(); ++i)
+                {
+                  if(gsi_stmt((*piter)[i]) == stmt)
+                    {
+                      break;
+                  }
+              }
+              if(i < piter->length())
+                {
+                  break;
+              }
+          }
+          piter->safe_push(gsi);
+          break;
+      }
+      gsi_next(&gsi);
+  }
+
+  return false;
+}
+
+static void
+gather_control_var_defs(tree var, vec<gimple_stmt_iterator>* piter)
+{
+  piter->create(16);
+  walk_use_def_chains(var, ctrl_var_cb, (void*)piter, false);
+}
+
+static void
+dump_fn_body(FILE* dump_file, const char* title)
+{
+  tree var;
+  int i;
+  basic_block bb;
+
+  fprintf(dump_file, "==============================\n%s\n========================\n", title);
+
+  print_generic_decl(dump_file, current_function_decl, 0);
+  fprintf(dump_file, "\n{\n");
+
+  FOR_EACH_LOCAL_DECL(DECL_STRUCT_FUNCTION(current_function_decl), i, var) {
+      print_generic_decl(dump_file, var, 0);
+      fprintf(dump_file, "\n");
+  }
+  for(i = 1; i < num_ssa_names; ++i) {
+      var = ssa_name(i);
+      if(var && !SSA_NAME_VAR(var)) {
+          fprintf(dump_file, "\t");
+          print_generic_expr(dump_file, var, 0);
+          fprintf(dump_file, "\n");
+      }
+  }
+
+  FOR_EACH_BB(bb) {
+      fprintf(dump_file, "L%d:\n", bb->index);
+      gimple_stmt_iterator gsi;
+      for(gsi = gsi_start_phis(bb); !gsi_end_p(gsi); gsi_next(&gsi)) {
+          gimple stmt = gsi_stmt(gsi);
+          fprintf(dump_file, "\t#");
+          print_gimple_stmt(dump_file, stmt, 0, 0);
+      }
+      for(gsi = gsi_start_bb(bb); !gsi_end_p(gsi); gsi_next(&gsi)) {
+          gimple stmt = gsi_stmt(gsi);
+          fprintf(dump_file, "\t");
+          print_gimple_stmt(dump_file, stmt, 0, 0);
+      }
+      edge e;
+      gimple stmt;
+      edge true_edge, false_edge;
+      stmt = last_stmt (bb);
+
+      if (stmt && gimple_code (stmt) == GIMPLE_COND) {
+
+          extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
+
+          fprintf(dump_file, "\tgoto L%d", true_edge->dest->index);
+          fprintf(dump_file, "\n");
+          fprintf(dump_file, "else\n");
+          fprintf(dump_file, "\tgoto L%d", false_edge->dest->index);
+          fprintf(dump_file, "\n");
+          continue;
+      }
+      e = find_fallthru_edge (bb->succs);
+      if (e && e->dest != bb->next_bb) {
+          fprintf(dump_file, "\tgoto L%d", e->dest->index);
+          fprintf(dump_file, "\n");
+      }
+  }
+
+  fprintf(dump_file, "}\n");
+  fflush(dump_file);
+}
+
+
+static void
+parallelize_loop(struct loop* l)
+{
+  if(dump_file) {
+      fprintf(dump_file, "parallelize loop %d\n", l->num);
+  }
+  unsigned i;
+  basic_block *bbs = get_loop_body (l);
+  vec<basic_block> loop_blocks;
+  loop_blocks.create(l->num_nodes);
+
+  for (i = 0; i < l->num_nodes; i++) {
+      if(dump_file) {
+          fprintf(dump_file, " %d", bbs[i]->index);
+      }
+      loop_blocks.quick_push(bbs[i]);
+  }
+  if(dump_file) {
+      fprintf(dump_file, "\n");
+  }
+  free (bbs);
+
+  edge latch, exit;
+  basic_block hdr_blk;
+
+  latch = loop_latch_edge(l);
+  exit = single_dom_exit(l);
+  hdr_blk = exit->src;
+
+  tree ctrl_var = find_ctrl_var(hdr_blk);
+
+  if(dump_file) {
+      fprintf(dump_file, "loop control var ");
+      print_generic_expr(dump_file, ctrl_var, 0);
+      fprintf(dump_file, "\n");
+  }
+
+  vec<gimple_stmt_iterator> ctrl_var_defs;
+  gather_control_var_defs(ctrl_var, &ctrl_var_defs);
+  if(dump_file) {
+      int i;
+      for(i = 0; i < ctrl_var_defs.length(); ++i) {
+          print_gimple_stmt(dump_file, gsi_stmt(ctrl_var_defs[i]), 0, 0);
+      }
+  }
+
+  if(dump_file) {
+      dump_fn_body(dump_file, "BEFORE");
+  }
+
+
+  if(dump_file) {
+      fprintf(dump_file, "latch edge %d -> %d\n", latch->src->index, latch->dest->index);
+      fprintf(dump_file, "exit edge %d -> %d\n", exit->src->index, exit->dest->index);
+      fprintf(dump_file, "redirecting %d -> %d\n", latch->src->index, exit->dest->index);
+  }
+
+  vec<struct phi_arg_d*> phi_args;
+  gimple_stmt_iterator phi_iter;
+
+  phi_args.create(4);
+  for(phi_iter = gsi_start_phis(latch->dest); !gsi_end_p(phi_iter); gsi_next(&phi_iter)) {
+      gimple phi_stmt = gsi_stmt(phi_iter);
+      unsigned i;
+
+      for(i = 0; i < gimple_phi_num_args(phi_stmt); ++i) {
+          edge e = gimple_phi_arg_edge(phi_stmt, i);
+          if(e->src->index == latch->src->index) {
+              phi_args.safe_push(gimple_phi_arg(phi_stmt, i));
+              break;
+          }
+      }
+  }
+
+
+  if(!redirect_edge_and_branch(latch, exit->dest)) {
+      redirect_edge_and_branch_force(latch, exit->dest);
+  }
+
+  for(phi_iter = gsi_start_phis(exit->dest); !gsi_end_p(phi_iter); gsi_next(&phi_iter)) {
+      gimple phi_stmt = gsi_stmt(phi_iter);
+      unsigned i, j;
+
+      for(i = 0; i < gimple_phi_num_args(phi_stmt); ++i) {
+          edge e = gimple_phi_arg_edge(phi_stmt, i);
+          if(e->src->index == latch->src->index && gimple_phi_arg_def(phi_stmt, i) == NULL_TREE) {
+              tree def_var = gimple_phi_result(phi_stmt);
+              for(j = 0; j < phi_args.length(); ++j) {
+                  struct phi_arg_d* pd = phi_args[j];
+                  tree arg_var = get_use_from_ptr (&pd->imm_use);
+                  if(SSA_NAME_VAR(def_var) != NULL_TREE && SSA_NAME_VAR(def_var) == SSA_NAME_VAR(arg_var)) {
+                      gimple_phi_set_arg(phi_stmt, i, pd);
+                  }
+              }
+          }
+      }
+  }
+
+
+
+  if(dump_file) {
+      dump_fn_body(dump_file, "AFTER REDIRECT");
+  }
+
+
+  if(can_remove_branch_p(exit)) {
+      if(dump_file) {
+          fprintf(dump_file, "can remove exit branch\n");
+      }
+      basic_block exit_bb = exit->dest;
+      remove_branch(exit);
+      vec<basic_block> v;
+      v.create(1);
+      v.quick_push(exit_bb);
+      iterate_fix_dominators(CDI_DOMINATORS, v, true);
+  }
+  else {
+      if(dump_file) {
+          fprintf(dump_file, "can not remove exit branch\n");
+      }
+  }
+
+  if(dump_file) {
+      dump_fn_body(dump_file, "AFTER REMOVE EXIT");
+  }
+
+
+  basic_block last_def = get_immediate_dominator(CDI_DOMINATORS, hdr_blk);
+  int def_idx = -1;
+  tree def_var = NULL_TREE;
+  if(last_def != NULL) {
+      for(i = 0; i < ctrl_var_defs.length(); ++i) {
+          if(ctrl_var_defs[i].bb == last_def) {
+              break;
+          }
+      }
+      if(i < ctrl_var_defs.length()) {
+          def_idx = i;
+      }
+  }
+
+  if(def_idx >= 0) {
+      if(dump_file) {
+          fprintf(dump_file, "last ctrl var def in block %d\n", last_def->index);
+      }
+      gimple_stmt_iterator gsi = ctrl_var_defs[def_idx];
+      gimple stmt = gsi_stmt(gsi);
+      def_var = get_gimple_def_var(stmt);
+  }
+
+  for(i = 0; i < ctrl_var_defs.length(); ++i) {
+      int j;
+      gimple_stmt_iterator gsi = ctrl_var_defs[i];
+      for(j = 0; j < loop_blocks.length(); ++j) {
+          if(gsi.bb == loop_blocks[j]) {
+              break;
+          }
+      }
+      if(j < loop_blocks.length()) {
+          gimple stmt = gsi_stmt(gsi);
+          tree lhs = get_gimple_def_var(stmt);
+          if(def_var != NULL_TREE) {
+              replace_uses_by(lhs, def_var);
+              gsi_remove(&gsi, true);
+          }
+      }
+      else if(dominated_by_p(CDI_DOMINATORS, hdr_blk, gsi.bb)) {
+          if(dump_file) {
+              fprintf(dump_file, "use in block %d dominates header %d\n", gsi.bb->index, hdr_blk->index);
+          }
+          gimple stmt = gsi_stmt(gsi);
+          if(gimple_code(stmt) != GIMPLE_PHI) {
+              tree lhs = get_gimple_def_var(stmt);
+              gimple call_stmt = build_call(gimple_location(stmt), builtin_decl_explicit(BUILT_IN_OACC_GET_GLOBAL_ID), 1, build_int_cst(TREE_TYPE(lhs), 0));
+
+              tree tmp_var = create_tmp_reg(TREE_TYPE(lhs), "_oacc_tmp");
+              tmp_var = make_ssa_name_fn(cfun, tmp_var, call_stmt);
+              set_gimple_def_var(call_stmt, tmp_var);
+
+              gimple add_stmt = build_assign(PLUS_EXPR, tmp_var, lhs);
+              tree new_var = make_ssa_name_fn(cfun, SSA_NAME_VAR(lhs), add_stmt);
+              set_gimple_def_var(add_stmt, new_var);
+
+              gen_add(&gsi, call_stmt);
+              gen_add(&gsi, add_stmt);
+
+
+          }
+      }
+  }
+
+  if(dump_file) {
+      dump_fn_body(dump_file, "AFTER CTRL VAR");
+  }
+
+}
+
+static void
+mark_kernels_parallel(tree kernel_fn)
+{
+  if(!oacc_kernels) {
+      oacc_kernels = BITMAP_GGC_ALLOC();
+  }
+  bitmap_set_bit(oacc_kernels, DECL_UID(kernel_fn));
+}
+
+static void
+parallelize_loops(struct loop* root)
+{
+  if(root->inner == NULL) {
+      return;
+  }
+  struct loop* ploop;
+  for(ploop = root->inner; ploop != NULL; ploop = ploop->next) {
+      parallelize_loop(ploop);
+  }
+}
+
+static void
+expand_oacc_kernels(gimple_stmt_iterator* gsi)
+{
+  unsigned i;
+  gimple stmt = gsi_stmt(*gsi);
+
+  tree child_fn = gimple_acc_kernels_child_fn(stmt);
+  struct function* child_cfun = DECL_STRUCT_FUNCTION(child_fn);
+  bool is_paral = false;
+  int save_opt_level = -1;
+
+  push_cfun(child_cfun);
+  if(optimize < 1) {
+      save_opt_level = optimize;
+      ++optimize;
+  }
+
+    {
+      basic_block bb;
+      FOR_EACH_BB(bb) {
+          gimple_stmt_iterator gsi;
+          for(gsi = gsi_start_bb(bb); !gsi_end_p(gsi); gsi_next(&gsi)) {
+              gimple stmt = gsi_stmt(gsi);
+              gimple_set_modified (stmt, true);
+              update_stmt_operands(stmt);
+          }
+      }
+    }
+  update_ssa(TODO_update_ssa);
+  loop_optimizer_init (LOOPS_NORMAL | LOOPS_HAVE_RECORDED_EXITS);
+  rewrite_into_loop_closed_ssa (NULL, TODO_update_ssa);
+  scev_initialize ();
+  struct loops* loops = current_loops;
+  struct tree_niter_desc niter_desc;
+
+  niter_desc.niter = NULL_TREE;
+  if(loops != NULL && loops->tree_root != NULL) {
+      if(loops_parallelizable_p(loops->tree_root, &niter_desc)) {
+          mark_kernels_parallel(child_fn);
+          is_paral = true;
+      }
+  }
+
+  scev_finalize();
+  if(save_opt_level >= 0) {
+      optimize = save_opt_level;
+  }
+    {
+      basic_block bb;
+      FOR_EACH_BB(bb) {
+          gimple_stmt_iterator gsi;
+          for(gsi = gsi_start_bb(bb); !gsi_end_p(gsi); gsi_next(&gsi)) {
+              gimple stmt = gsi_stmt(gsi);
+              gimple_set_modified (stmt, true);
+              update_stmt_operands(stmt);
+          }
+      }
+    }
+  pop_cfun();
+
+  if(is_paral) {
+      tree type, kernel_handle, buffer_handle, queue_handle;
+
+      type = build_pointer_type(void_type_node);
+      kernel_handle = create_tmp_reg(type, "_oacc_tmp");
+      buffer_handle = create_tmp_reg(type, "_oacc_tmp");
+      queue_handle = create_tmp_reg(type, "_oacc_tmp");
+
+      const char* src_file = NULL;
+      int src_line = 0;
+      location_t locus = gimple_location(stmt);
+
+      src_file = LOCATION_FILE(locus);
+      src_line = LOCATION_LINE(locus);
+      if(dump_file) {
+          fprintf(dump_file, "file: '%s', line %d\n", src_file, src_line);
+      }
+
+      gimple call_stmt;
+
+      if(flag_enable_openacc_profiling) {
+          gen_replace(gsi, build_call(locus, builtin_decl_explicit(BUILT_IN_OACC_START_PROFILING), 0));
+
+          /* OACC_check_cur_dev */
+          gen_add(gsi, build_call(locus, builtin_decl_explicit(BUILT_IN_OACC_CHECK_CUR_DEV), 0));
+      }
+      else {
+          gen_replace(gsi, build_call(locus, builtin_decl_explicit(BUILT_IN_OACC_CHECK_CUR_DEV), 0));
+      }
+
+      /* OACC_get_kernel */
+      call_stmt = build_call(locus, builtin_decl_explicit(BUILT_IN_OACC_GET_KERNEL), 2, 
+                             build_string_literal(strlen(ocl_module)+1, ocl_module), build_string_literal(strlen(IDENTIFIER_POINTER(DECL_NAME(child_fn)))+1, IDENTIFIER_POINTER(DECL_NAME(child_fn))));
+      gimple_call_set_lhs(call_stmt, kernel_handle);
+      gen_add(gsi, call_stmt);
+
+      call_stmt = build_call(locus, builtin_decl_explicit(BUILT_IN_OACC_CREATE_EVENTS), 2, 
+                             build_string_literal(strlen(src_file)+1, src_file), build_int_cst(uint32_type_node, src_line));
+      gimple_call_set_lhs(call_stmt, queue_handle);
+      gen_add(gsi, call_stmt);
+
+      gen_add(gsi, build_call(locus, builtin_decl_explicit(BUILT_IN_OACC_ENQUEUE_EVENTS), 3, queue_handle, 
+                              build_int_cst(uint32_type_node, gimple_acc_kernels_nparams(stmt)), build_int_cst(uint32_type_node, OACC_PF_DATAIN)));
+
+      gen_add(gsi, build_call(locus, builtin_decl_explicit(BUILT_IN_OACC_ENQUEUE_EVENTS), 3, queue_handle, 
+                              build_int_cst(uint32_type_node, 1), build_int_cst(uint32_type_node, OACC_PF_EXEC)));
+
+      gen_add(gsi, build_call(locus, builtin_decl_explicit(BUILT_IN_OACC_ENQUEUE_EVENTS), 3, queue_handle,
+                              build_int_cst(uint32_type_node, gimple_acc_kernels_nparams(stmt)), build_int_cst(uint32_type_node, OACC_PF_DATAOUT)));
+
+      /* OACC_set_arg */
+      tree bits_per_byte = build_int_cst(uint32_type_node, 8);
+      tree chk_presence = integer_one_node;
+
+      for(i = 0; i < gimple_acc_kernels_nparams(stmt); ++i) {
+          tree arg = gimple_acc_kernels_params_ptr(stmt)[i];
+          if(is_gimple_reg(arg)) continue;
+          tree type = TREE_TYPE(arg);
+          tree size = TYPE_SIZE(type);
+          tree idx = build_int_cst(uint32_type_node, i);
+
+          call_stmt = build_call(locus, builtin_decl_explicit(BUILT_IN_OACC_COPYIN), 5, build_fold_addr_expr(arg),
+                                 fold_binary(TRUNC_DIV_EXPR, uint32_type_node, size, bits_per_byte), chk_presence, queue_handle, idx);
+          gimple_call_set_lhs(call_stmt, buffer_handle);
+          gen_add(gsi, call_stmt);
+
+          gen_add(gsi, build_call(locus, builtin_decl_explicit(BUILT_IN_OACC_SET_KERNEL_ARG), 3, kernel_handle, idx, buffer_handle));
+      }
+
+
+      gen_add(gsi, build_call(locus, builtin_decl_explicit(BUILT_IN_OACC_ADVANCE_EVENTS), 1, queue_handle));
+
+      /* OACC_start_kernel */
+      tree worksize;
+      if(niter_desc.niter != NULL_TREE && TREE_CODE(niter_desc.niter) == INTEGER_CST) {
+          worksize = niter_desc.niter;
+      }
+      else {
+          worksize = build_int_cst(uint32_type_node, niter_desc.max.to_shwi());
+      }
+
+      gen_add(gsi, build_call(locus, builtin_decl_explicit(BUILT_IN_OACC_START_KERNEL), 4, kernel_handle, worksize, queue_handle, build_int_cst(uint32_type_node, 0)));
+      gen_add(gsi, build_call(locus, builtin_decl_explicit(BUILT_IN_OACC_ADVANCE_EVENTS), 1, queue_handle));
+
+      /* OACC_copyout */
+      for(i = 0; i < gimple_acc_kernels_nparams(stmt); ++i) {
+          tree arg = gimple_acc_kernels_params_ptr(stmt)[i];
+          if(is_gimple_reg(arg)) continue;
+          tree type = TREE_TYPE(arg);
+          tree size = TYPE_SIZE(type);
+          tree idx = build_int_cst(uint32_type_node, i);
+
+          gen_add(gsi, build_call(locus, builtin_decl_explicit(BUILT_IN_OACC_COPYOUT), 5, build_fold_addr_expr(arg),
+                                  fold_binary(TRUNC_DIV_EXPR, uint32_type_node, size, bits_per_byte), chk_presence, queue_handle, idx));
+      }		
+
+      gen_add(gsi, build_call(locus, builtin_decl_explicit(BUILT_IN_OACC_ADVANCE_EVENTS), 1, queue_handle));
+      gen_add(gsi, build_call(locus, builtin_decl_explicit(BUILT_IN_OACC_WAIT_EVENTS), 1, queue_handle));
+
+  }
+}
+
+static void
+generate_opencl(void)
+{
+  rewrite_out_of_ssa(&SA);
+  cleanup_tree_cfg();
+  generate_opencl_kernel(ocl_module, current_function_decl, &SA);
+  finish_out_of_ssa(&SA);
+}
+
+
+/* if we generated OenCL code, function body isn't needed */
+static void
+finish_current_fn(void)
+{
+  if(dump_file) {
+      fprintf(dump_file, "gimple_body=%p\n", cfun->gimple_body);
+      fprintf(dump_file, "gimple_df=%p\n", cfun->gimple_df);
+      fprintf(dump_file, "cfg=%p\n", cfun->cfg);
+  }
+  /*
+     struct cgraph_node* node = cgraph_get_node(current_function_decl);
+     free_dominance_info(CDI_DOMINATORS);
+     free_dominance_info(CDI_POST_DOMINATORS);
+     cgraph_remove_node(node);
+   */
+}
+
+/* Main entry point for expanding OpenACC.  */
+
+static unsigned int
+execute_expand_oacc (void)
+{
+  basic_block bb;
+
+  if(oacc_kernels && bitmap_bit_p(oacc_kernels, DECL_UID(current_function_decl))) {
+      parallelize_loops(current_loops->tree_root);
+      generate_opencl();
+      //finish_current_fn();
+      return 0;
+  }
+
+  FOR_EACH_BB(bb) {
+      gimple_stmt_iterator gsi;
+      for(gsi = gsi_start_bb(bb); !gsi_end_p(gsi); gsi_next(&gsi)) {
+          gimple stmt = gsi_stmt(gsi);
+          switch(gimple_code(stmt)) {
+            case GIMPLE_ACC_KERNELS:
+              expand_oacc_kernels(&gsi);
+              break;
+            default:
+              break;
+          }
+      }
+  }
+  return 0;
+}
+
+/* OpenACC expansion */
+
+static bool
+gate_expand_oacc (void)
+{
+  return (flag_openacc != 0);
+}
+
+
+namespace {
+const pass_data pass_data_expand_oacc =
+{
+  GIMPLE_PASS,
+  "oaccexp",				/* name */
+  OPTGROUP_NONE,                        /* optinfo_flags */
+  gate_expand_oacc,			/* gate */
+  execute_expand_oacc,			/* execute */
+  TV_NONE,				/* tv_id */
+  PROP_cfg,			/* properties_required */
+  0,					/* properties_provided */
+  0,					/* properties_destroyed */
+  0,					/* todo_flags_start */
+  TODO_update_ssa                 		/* todo_flags_finish */
+};
+
+class pass_expand_oacc : public gimple_opt_pass
+{
+public:
+  pass_expand_oacc(gcc::context *ctxt)
+    :
+      gimple_opt_pass(pass_data_expand_oacc,
+                      ctxt)
+  {}
+
+  /* opt_pass methods: */
+  bool gate () { return gate_expand_oacc ();
+  }
+  unsigned int execute () { return
+      execute_expand_oacc (); }
+
+}; // class pass_expand_oacc
+}
+
+gimple_opt_pass *
+make_pass_expand_oacc (gcc::context *ctxt)
+{
+  return new pass_expand_oacc (ctxt);
+}
+
+/* Diagnose OpenACC structured block violations  */
+
+/* Check for mismatched contexts and generate an error if needed.  Return
+   true if an error is detected.  */
+
+static bool
+diagnose_cb(gimple_stmt_iterator *gsi_p, gimple branch_ctx, gimple label_ctx)
+{
+  if (label_ctx == branch_ctx)
+    return false;
+  /* If it's obvious we have an invalid entry, be specific about the error.  */
+  if (branch_ctx == NULL)
+    error ("invalid entry to OpenACC structured block");
+  else
+    /* Otherwise, be vague and lazy, but efficient.  */
+    error ("invalid branch to/from an OpenACC structured block");
+
+  gsi_replace (gsi_p, gimple_build_nop (), false);
+  return true;
+}
+
+static void
+get_recursive_seq(enum gimple_code code, gimple stmt, vec<gimple_seq*>* seq)
+{
+  switch(code) {
+    case GIMPLE_ACC_KERNELS:
+    case GIMPLE_ACC_PARALLEL:
+    case GIMPLE_ACC_LOOP:
+      seq->safe_push(gimple_acc_body_ptr(stmt));
+      break;
+    default:
+      break;
+  }
+}
+
+static unsigned int
+diagnose_oacc_structured_block_errors (void)
+{
+
+  vec<enum gimple_code> oacc_codes;
+
+  oacc_codes.create(3);
+  oacc_codes.quick_push(GIMPLE_ACC_KERNELS);
+  oacc_codes.quick_push(GIMPLE_ACC_PARALLEL);
+  oacc_codes.quick_push(GIMPLE_ACC_LOOP);
+
+  diagnose_gotos(&oacc_codes, get_recursive_seq, diagnose_cb);
+  return 0;
+}
+
+static bool
+gate_diagnose_oacc_blocks (void)
+{
+  return flag_openacc != 0;
+}
+
+
+namespace {
+const pass_data pass_data_diagnose_oacc_blocks =
+{
+  GIMPLE_PASS,
+  "*diagnose_oacc_blocks",		/* name */
+  OPTGROUP_NONE,                      /* optinfo_flags */
+  gate_diagnose_oacc_blocks,		/* gate */
+  diagnose_oacc_structured_block_errors,	/* execute */
+  TV_NONE,				/* tv_id */
+  PROP_gimple_any,			/* properties_required */
+  0,					/* properties_provided */
+  0,					/* properties_destroyed */
+  0,					/* todo_flags_start */
+  0,					/* todo_flags_finish */
+};
+
+class pass_diagnose_oacc_blocks : public gimple_opt_pass
+{
+public:
+  pass_diagnose_oacc_blocks(gcc::context *ctxt)
+    : gimple_opt_pass(pass_data_diagnose_oacc_blocks, ctxt)
+    {}
+
+  /* opt_pass methods: */
+  bool gate () { return gate_diagnose_oacc_blocks (); }
+  unsigned int execute () { return diagnose_oacc_structured_block_errors (); }
+
+}; // class pass_diagnose_oacc_blocks
+}
+
+gimple_opt_pass *
+make_pass_diagnose_oacc_blocks (gcc::context *ctxt)
+{
+  return new pass_diagnose_oacc_blocks (ctxt);
+}
+
+#include "gt-oacc-low.h"
diff --git a/gcc/omp-low.c b/gcc/omp-low.c
index 221ae71a1c3..862fdde52ac 100644
--- a/gcc/omp-low.c
+++ b/gcc/omp-low.c
@@ -2367,6 +2367,71 @@ lower_rec_simd_input_clauses (tree new_var, omp_context *ctx, int &max_vf,
   return true;
 }
 
+tree
+acc_reduction_init (tree clause, tree type)
+{
+  location_t loc = ACC_CLAUSE_LOCATION (clause);
+  switch (ACC_CLAUSE_REDUCTION_CODE (clause))
+    {
+    case PLUS_EXPR:
+    case MINUS_EXPR:
+    case BIT_IOR_EXPR:
+    case BIT_XOR_EXPR:
+    case TRUTH_OR_EXPR:
+    case TRUTH_ORIF_EXPR:
+    case TRUTH_XOR_EXPR:
+    case NE_EXPR:
+      return build_zero_cst (type);
+
+    case MULT_EXPR:
+    case TRUTH_AND_EXPR:
+    case TRUTH_ANDIF_EXPR:
+    case EQ_EXPR:
+      return fold_convert_loc (loc, type, integer_one_node);
+
+    case BIT_AND_EXPR:
+      return fold_convert_loc (loc, type, integer_minus_one_node);
+
+    case MAX_EXPR:
+      if (SCALAR_FLOAT_TYPE_P (type))
+        {
+          REAL_VALUE_TYPE max, min;
+          if (HONOR_INFINITIES (TYPE_MODE (type)))
+            {
+              real_inf (&max);
+              real_arithmetic (&min, NEGATE_EXPR, &max, NULL);
+            }
+          else
+            real_maxval (&min, 1, TYPE_MODE (type));
+          return build_real (type, min);
+        }
+      else
+        {
+          gcc_assert (INTEGRAL_TYPE_P (type));
+          return TYPE_MIN_VALUE (type);
+        }
+
+    case MIN_EXPR:
+      if (SCALAR_FLOAT_TYPE_P (type))
+        {
+          REAL_VALUE_TYPE max;
+          if (HONOR_INFINITIES (TYPE_MODE (type)))
+            real_inf (&max);
+          else
+            real_maxval (&max, 0, TYPE_MODE (type));
+          return build_real (type, max);
+        }
+      else
+        {
+          gcc_assert (INTEGRAL_TYPE_P (type));
+          return TYPE_MAX_VALUE (type);
+        }
+
+    default:
+      gcc_unreachable ();
+    }
+}
+
 /* Generate code to implement the input clauses, FIRSTPRIVATE and COPYIN,
    from the receiver (aka child) side and initializers for REFERENCE_TYPE
    private variables.  Initialization statements go in ILIST, while calls
diff --git a/gcc/passes.def b/gcc/passes.def
index 84eb3f37e57..ab0075616a7 100644
--- a/gcc/passes.def
+++ b/gcc/passes.def
@@ -32,8 +32,10 @@ along with GCC; see the file COPYING3.  If not see
     by these passes.  */
   INSERT_PASSES_AFTER (all_lowering_passes)
   NEXT_PASS (pass_warn_unused_result);
+  NEXT_PASS (pass_diagnose_oacc_blocks);
   NEXT_PASS (pass_diagnose_omp_blocks);
   NEXT_PASS (pass_diagnose_tm_blocks);
+  NEXT_PASS (pass_lower_oacc);
   NEXT_PASS (pass_mudflap_1);
   NEXT_PASS (pass_lower_omp);
   NEXT_PASS (pass_lower_cf);
@@ -52,6 +54,7 @@ along with GCC; see the file COPYING3.  If not see
   NEXT_PASS (pass_ipa_function_and_variable_visibility);
   NEXT_PASS (pass_early_local_passes);
   PUSH_INSERT_PASSES_WITHIN (pass_early_local_passes)
+      NEXT_PASS (pass_expand_oacc);
       NEXT_PASS (pass_fixup_cfg);
       NEXT_PASS (pass_init_datastructures);
 
diff --git a/gcc/testsuite/gfortran.dg/gacc/_branch.f95 b/gcc/testsuite/gfortran.dg/gacc/_branch.f95
new file mode 100644
index 00000000000..ec3eed9345b
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/_branch.f95
@@ -0,0 +1,60 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc" } 
+
+program test
+	implicit none
+
+	integer :: i
+
+	if (.true.) then
+		!$acc parallel 
+	end if ! { dg-error "Unexpected" }
+	!$acc end parallel 
+	end if
+
+	if (.true.) then
+		!$acc kernels 
+	end if ! { dg-error "Unexpected" }
+	!$acc end kernels 
+	end if
+
+	!$acc parallel
+	if (.true.) then
+		!$acc end parallel ! { dg-error "Unexpected" }
+	end if 
+	!$acc end parallel
+
+	!$acc kernels
+	if (.true.) then
+		!$acc end kernels ! { dg-error "Unexpected" }
+	end if 
+	!$acc end kernels
+
+	!$acc parallel
+	if (.true.) then
+	end if
+	!$acc end parallel
+
+	!$acc kernels
+	if (.true.) then
+	end if
+	!$acc end kernels
+
+	if (.true.) then
+		!$acc parallel
+		!$acc end parallel
+	end if
+
+	if (.true.) then
+		!$acc kernels
+		!$acc end kernels
+	end if
+
+	!acc parallel
+	! TODO: implement in lowering pass
+	goto 10 ! { dg-error "branch|exit" }
+	!$acc end parallel
+10	i = 0
+
+
+end program test 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/_continuation-free-form.f95 b/gcc/testsuite/gfortran.dg/gacc/_continuation-free-form.f95
new file mode 100644
index 00000000000..df32d9cdc73
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/_continuation-free-form.f95
@@ -0,0 +1,24 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc" } 
+
+program test
+	implicit none
+
+	integer :: i
+	real :: x
+
+	!$acc parallel &
+	!$acc loop & ! continuation
+	!$acc & reduction(+:x)
+
+	! this line must be ignored
+	!$acc ! kernels
+	do i = 1,10
+		x = x + 0.3
+	enddo
+	! continuation must begin with sentinel
+	!$acc end parallel & ! { dg-error "Unclassifiable OpenACC directive" }
+	! loop
+
+	print *, x
+end
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/_data-clauses.f95 b/gcc/testsuite/gfortran.dg/gacc/_data-clauses.f95
new file mode 100644
index 00000000000..20b0c895ff8
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/_data-clauses.f95
@@ -0,0 +1,262 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fmax-errors=100" } 
+
+! without suarrays, since they are not implemented yet
+! todo: some of warnings are not necessary
+
+module test 
+	implicit none
+contains
+
+	subroutine foo (vi)
+	integer, value :: vi
+	integer :: i, ia(10)
+	complex :: c, ca(10)
+	real, target:: r
+	real :: ra(10)
+	real, pointer :: rp
+	real, dimension(:), allocatable :: aa
+	type t
+		integer :: i
+	end type
+	type(t) :: ti
+	type(t), allocatable :: tia
+	type(t), target :: tit
+	type(t), pointer :: tip
+	rp => r
+	tip => tit
+
+	!$acc parallel deviceptr (rp) ! { dg-error "POINTER" }
+	!$acc end parallel
+	!$acc parallel deviceptr (vi) ! { dg-error "VALUE" }
+	!$acc end parallel
+	!$acc parallel deviceptr (aa) ! { dg-error "ALLOCATABLE" }
+	!$acc end parallel
+
+	!$acc parallel deviceptr (i, c, r, ia, ca, ra, ti)
+	!$acc end parallel
+	!$acc kernels deviceptr (i, c, r, ia, ca, ra, ti)
+	!$acc end kernels
+	!$acc data deviceptr (i, c, r, ia, ca, ra, ti)
+	!$acc end data
+
+
+	!$acc parallel copy (tip) ! { dg-error "POINTER" }
+	!$acc end parallel
+	!$acc parallel copy (tia) ! { dg-error "ALLOCATABLE" }
+	!$acc end parallel
+	!$acc parallel deviceptr (i) copy (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+
+	!$acc parallel copy (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end parallel
+	!$acc kernels copy (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end kernels
+	!$acc data copy (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end data
+
+
+	!$acc parallel copyin (tip) ! { dg-error "POINTER" }
+	!$acc end parallel
+	!$acc parallel copyin (tia) ! { dg-error "ALLOCATABLE" }
+	!$acc end parallel
+	!$acc parallel deviceptr (i) copyin (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel copy (i) copyin (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+
+	!$acc parallel copyin (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end parallel
+	!$acc kernels copyin (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end kernels
+	!$acc data copyin (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end data
+
+
+	!$acc parallel copyout (tip) ! { dg-error "POINTER" }
+	!$acc end parallel
+	!$acc parallel copyout (tia) ! { dg-error "ALLOCATABLE" }
+	!$acc end parallel
+	!$acc parallel deviceptr (i) copyout (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel copy (i) copyout (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel copyin (i) copyout (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+
+	!$acc parallel copyout (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end parallel
+	!$acc kernels copyout (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end kernels
+	!$acc data copyout (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end data
+
+
+	!$acc parallel create (tip) ! { dg-error "POINTER" }
+	!$acc end parallel
+	!$acc parallel create (tia) ! { dg-error "ALLOCATABLE" }
+	!$acc end parallel
+	!$acc parallel deviceptr (i) create (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel copy (i) create (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel copyin (i) create (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel copyout (i) create (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+
+	!$acc parallel create (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end parallel
+	!$acc kernels create (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end kernels
+	!$acc data create (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end data
+
+
+	!$acc parallel present (tip) ! { dg-error "POINTER" }
+	!$acc end parallel
+	!$acc parallel present (tia) ! { dg-error "ALLOCATABLE" }
+	!$acc end parallel
+	!$acc parallel deviceptr (i) present (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel copy (i) present (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel copyin (i) present (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel copyout (i) present (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel create (i) present (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+
+	!$acc parallel present (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end parallel
+	!$acc kernels present (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end kernels
+	!$acc data present (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end data
+
+
+	!$acc parallel pcopy (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end parallel
+	!$acc parallel pcopyin (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end parallel
+	!$acc parallel pcopyout (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end parallel
+	!$acc parallel pcreate (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end parallel
+
+
+	!$acc parallel present_or_copy (tip) ! { dg-error "POINTER" }
+	!$acc end parallel
+	!$acc parallel present_or_copy (tia) ! { dg-error "ALLOCATABLE" }
+	!$acc end parallel
+	!$acc parallel deviceptr (i) present_or_copy (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel copy (i) present_or_copy (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel copyin (i) present_or_copy (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel copyout (i) present_or_copy (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel create (i) present_or_copy (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel present (i) present_or_copy (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+
+	!$acc parallel present_or_copy (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end parallel
+	!$acc kernels present_or_copy (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end kernels
+	!$acc data present_or_copy (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end data
+
+
+	!$acc parallel present_or_copyin (tip) ! { dg-error "POINTER" }
+	!$acc end parallel
+	!$acc parallel present_or_copyin (tia) ! { dg-error "ALLOCATABLE" }
+	!$acc end parallel
+	!$acc parallel deviceptr (i) present_or_copyin (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel copy (i) present_or_copyin (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel copyin (i) present_or_copyin (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel copyout (i) present_or_copyin (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel create (i) present_or_copyin (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel present (i) present_or_copyin (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel present_or_copy (i) present_or_copyin (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+
+	!$acc parallel present_or_copyin (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end parallel
+	!$acc kernels present_or_copyin (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end kernels
+	!$acc data present_or_copyin (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end data
+
+
+	!$acc parallel present_or_copyout (tip) ! { dg-error "POINTER" }
+	!$acc end parallel
+	!$acc parallel present_or_copyout (tia) ! { dg-error "ALLOCATABLE" }
+	!$acc end parallel
+	!$acc parallel deviceptr (i) present_or_copyout (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel copy (i) present_or_copyout (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel copyin (i) present_or_copyout (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel copyout (i) present_or_copyout (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel create (i) present_or_copyout (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel present (i) present_or_copyout (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel present_or_copy (i) present_or_copyout (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel present_or_copyin (i) present_or_copyout (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+
+	!$acc parallel present_or_copyout (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end parallel
+	!$acc kernels present_or_copyout (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end kernels
+	!$acc data present_or_copyout (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end data
+
+
+	!$acc parallel present_or_create (tip) ! { dg-error "POINTER" }
+	!$acc end parallel
+	!$acc parallel present_or_create (tia) ! { dg-error "ALLOCATABLE" }
+	!$acc end parallel
+	!$acc parallel deviceptr (i) present_or_create (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel copy (i) present_or_create (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel copyin (i) present_or_create (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel copyout (i) present_or_create (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel create (i) present_or_create (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel present (i) present_or_create (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel present_or_copy (i) present_or_create (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel present_or_copyin (i) present_or_create (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+	!$acc parallel present_or_copyout (i) present_or_create (i) ! { dg-warning "multiple clauses" }
+	!$acc end parallel
+
+	!$acc parallel present_or_create (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end parallel
+	!$acc kernels present_or_create (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end kernels
+	!$acc data present_or_create (i, c, r, ia, ca, ra, rp, ti, vi, aa)
+	!$acc end data
+
+	end subroutine foo
+	
+end module test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/_data-tree.f95 b/gcc/testsuite/gfortran.dg/gacc/_data-tree.f95
new file mode 100644
index 00000000000..523cb39d323
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/_data-tree.f95
@@ -0,0 +1,32 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! test for tree-dump-original and spaces-commas
+
+program test
+	implicit none
+	integer :: q, i, j, k, m, n, o, p, r, s, t, u, v, w
+	logical :: l
+
+	!$acc data if(l) copy(i), copyin(j), copyout(k), create(m) &
+	!$acc present(o), pcopy(p), pcopyin(r), pcopyout(s), pcreate(t) &
+	!$acc deviceptr(u)
+	!$acc end data
+
+end program test
+! { dg-final { scan-tree-dump "pragma acc data" "original" } } 
+
+! { dg-final { scan-tree-dump "if" "original" } }
+! { dg-final { scan-tree-dump "copy" "original" } } 
+! { dg-final { scan-tree-dump "copyin" "original" } } 
+! { dg-final { scan-tree-dump "copyout" "original" } } 
+! { dg-final { scan-tree-dump "create" "original" } } 
+
+! { dg-final { scan-tree-dump "present" "original" } } 
+! { dg-final { scan-tree-dump "present_or_copy" "original" } } 
+! { dg-final { scan-tree-dump "present_or_copyin" "original" } } 
+! { dg-final { scan-tree-dump "present_or_copyout" "original" } } 
+! { dg-final { scan-tree-dump "present_or_create" "original" } } 
+
+! { dg-final { scan-tree-dump "deviceptr" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/_declare-1.f95 b/gcc/testsuite/gfortran.dg/gacc/_declare-1.f95
new file mode 100644
index 00000000000..cc24937b958
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/_declare-1.f95
@@ -0,0 +1,11 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+program test
+	implicit none
+	integer :: i
+
+	!$acc declare copy(i)
+
+end program test
+! { dg-final { scan-tree-dump "pragma acc data copy" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/_declare.f95 b/gcc/testsuite/gfortran.dg/gacc/_declare.f95
new file mode 100644
index 00000000000..22144263ef0
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/_declare.f95
@@ -0,0 +1,9 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc" } 
+program test
+	implicit none
+	integer :: i
+
+	!$acc declare copy(i)
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/_directive-names.f95 b/gcc/testsuite/gfortran.dg/gacc/_directive-names.f95
new file mode 100644
index 00000000000..1be7eb9cd3a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/_directive-names.f95
@@ -0,0 +1,19 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc" } 
+
+program test
+	implicit none
+
+	!$acc parallel
+	!$acc end parallel
+
+	!$acc kernels
+	!$acc end kernels
+
+	!$acc data
+	!$acc end data
+
+	!$acc host_data
+	!$acc end host_data
+	
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/_host_data-tree.f95 b/gcc/testsuite/gfortran.dg/gacc/_host_data-tree.f95
new file mode 100644
index 00000000000..c3b13f8d0b5
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/_host_data-tree.f95
@@ -0,0 +1,12 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer :: i
+
+	!$acc host_data use_device(i)
+	!$acc end host_data
+end program test
+! { dg-final { scan-tree-dump "pragma acc host_data use_device" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/_if.f95 b/gcc/testsuite/gfortran.dg/gacc/_if.f95
new file mode 100644
index 00000000000..f543c8ad5dc
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/_if.f95
@@ -0,0 +1,53 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc" } 
+
+program test
+	implicit none
+
+	logical :: x
+	integer :: i
+
+	!$acc parallel if ! { dg-error "Unclassifiable OpenACC directive" }
+	!$acc parallel if () ! { dg-error "Invalid character" }
+	!$acc parallel if (i) ! { dg-error "scalar LOGICAL expression" }
+	!$acc end parallel 
+	!$acc parallel if (1) ! { dg-error "scalar LOGICAL expression" }
+	!$acc end parallel 
+	!$acc kernels if (i) ! { dg-error "scalar LOGICAL expression" }
+	!$acc end kernels 
+	!$acc kernels if ! { dg-error "Unclassifiable OpenACC directive" }
+	!$acc kernels if () ! { dg-error "Invalid character" }
+	!$acc kernels if (1) ! { dg-error "scalar LOGICAL expression" }
+	!$acc end kernels
+	!$acc data if ! { dg-error "Unclassifiable OpenACC directive" }
+	!$acc data if () ! { dg-error "Invalid character" }
+	!$acc data if (i) ! { dg-error "scalar LOGICAL expression" }
+	!$acc end data 
+	!$acc data if (1) ! { dg-error "scalar LOGICAL expression" }
+	!$acc end data 
+
+	! at most one if clause may appear
+	!$acc parallel if (.false.) if (.false.) { dg-error "Unclassifiable OpenACC directive" }
+	!$acc kernels if (.false.) if (.false.) { dg-error "Unclassifiable OpenACC directive" }
+	!$acc data if (.false.) if (.false.) { dg-error "Unclassifiable OpenACC directive" }
+
+	!$acc parallel if (x)
+	!$acc end parallel
+	!$acc parallel if (.true.)
+	!$acc end parallel
+	!$acc parallel if (i.gt.1)
+	!$acc end parallel
+	!$acc kernels if (x)
+	!$acc end kernels
+	!$acc kernels if (.true.)
+	!$acc end kernels
+	!$acc kernels if (i.gt.1)
+	!$acc end kernels
+	!$acc data if (x)
+	!$acc end data
+	!$acc data if (.true.)
+	!$acc end data
+	!$acc data if (i.gt.1)
+	!$acc end data
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/_kernels-tree.f95 b/gcc/testsuite/gfortran.dg/gacc/_kernels-tree.f95
new file mode 100644
index 00000000000..08614e13a5c
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/_kernels-tree.f95
@@ -0,0 +1,33 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! test for tree-dump-original and spaces-commas
+
+program test
+	implicit none
+	integer :: q, i, j, k, m, n, o, p, r, s, t, u, v, w
+	logical :: l
+
+	!$acc kernels if(l) async copy(i), copyin(j), copyout(k), create(m) &
+	!$acc present(o), pcopy(p), pcopyin(r), pcopyout(s), pcreate(t) &
+	!$acc deviceptr(u)
+	!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "pragma acc kernels" "original" } } 
+
+! { dg-final { scan-tree-dump "if" "original" } }
+! { dg-final { scan-tree-dump "async" "original" } } 
+! { dg-final { scan-tree-dump "copy" "original" } } 
+! { dg-final { scan-tree-dump "copyin" "original" } } 
+! { dg-final { scan-tree-dump "copyout" "original" } } 
+! { dg-final { scan-tree-dump "create" "original" } } 
+
+! { dg-final { scan-tree-dump "present" "original" } } 
+! { dg-final { scan-tree-dump "present_or_copy" "original" } } 
+! { dg-final { scan-tree-dump "present_or_copyin" "original" } } 
+! { dg-final { scan-tree-dump "present_or_copyout" "original" } } 
+! { dg-final { scan-tree-dump "present_or_create" "original" } } 
+
+! { dg-final { scan-tree-dump "deviceptr" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/_list.f95 b/gcc/testsuite/gfortran.dg/gacc/_list.f95
new file mode 100644
index 00000000000..02aaae5650c
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/_list.f95
@@ -0,0 +1,111 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fmax-errors=100" } 
+
+program test 
+	implicit none
+
+	integer :: i, j, k, l, a(10)
+	common /b/ j, k
+	real, pointer :: p1 => NULL()
+	complex :: c, d(10)
+
+	!$acc parallel private(i)
+	!$acc end parallel
+
+	!$acc parallel private(a)
+	!$acc end parallel
+
+	!$acc parallel private(c, d)
+	!$acc end parallel
+
+	!$acc parallel private(i, j, k, l, a)
+	!$acc end parallel	
+
+	!$acc parallel private (i) private (j)
+	!$acc end parallel
+
+	!$acc parallel private ! { dg-error "Unclassifiable OpenACC directive" }
+
+	!$acc parallel private() ! { dg-error "Syntax error in OpenACC variable list" }
+
+	!$acc parallel private(a(1:3)) ! { dg-error "Syntax error in OpenACC variable list" }
+
+	!$acc parallel private(10) ! { dg-error "Syntax error in OpenACC variable list" }
+
+	!$acc parallel private(/b/, /b/) ! { dg-warning "present on multiple clauses" }
+	!$acc end parallel
+
+	!$acc parallel private(i, j, i) ! { dg-warning "present on multiple clauses" }
+	!$acc end parallel
+
+	!$acc parallel private(p1) ! { dg-error "POINTER" }
+	!$acc end parallel
+
+	!$acc parallel firstprivate(i)
+	!$acc end parallel
+
+	!$acc parallel firstprivate(c, d)
+	!$acc end parallel
+
+	!$acc parallel firstprivate(a)
+	!$acc end parallel
+
+	!$acc parallel firstprivate(i, j, k, l, a)
+	!$acc end parallel	
+
+	!$acc parallel firstprivate (i) firstprivate (j)
+	!$acc end parallel
+
+	!$acc parallel firstprivate ! { dg-error "Unclassifiable OpenACC directive" }
+
+	!$acc parallel firstprivate() ! { dg-error "Syntax error in OpenACC variable list" }
+
+	!$acc parallel firstprivate(a(1:3)) ! { dg-error "Syntax error in OpenACC variable list" }
+
+	!$acc parallel firstprivate(10) ! { dg-error "Syntax error in OpenACC variable list" }
+
+	!$acc parallel firstprivate (/b/, /b/) ! { dg-warning "present on multiple clauses" }
+	!$acc end parallel
+
+	!$acc parallel firstprivate (i, j, i) ! { dg-warning "present on multiple clauses" }
+	!$acc end parallel
+
+	!$acc parallel firstprivate(p1) ! { dg-error "POINTER" }
+	!$acc end parallel
+
+	!$acc parallel private (i) firstprivate (i) ! { dg-warning "present on multiple clauses" }
+	!$acc end parallel
+
+	!$acc host_data use_device(i)
+	!$acc end host_data
+
+	!$acc host_data use_device(c, d)
+	!$acc end host_data
+
+	!$acc host_data use_device(a)
+	!$acc end host_data
+
+	!$acc host_data use_device(i, j, k, l, a)
+	!$acc end host_data	
+
+	!$acc host_data use_device (i) use_device (j)
+	!$acc end host_data
+
+	!$acc host_data use_device ! { dg-error "Unclassifiable OpenACC directive" }
+
+	!$acc host_data use_device() ! { dg-error "Syntax error in OpenACC variable list" }
+
+	!$acc host_data use_device(a(1:3)) ! { dg-error "Syntax error in OpenACC variable list" }
+
+	!$acc host_data use_device(10) ! { dg-error "Syntax error in OpenACC variable list" }
+
+	!$acc host_data use_device(/b/, /b/) ! { dg-warning "present on multiple clauses" }
+	!$acc end host_data
+
+	!$acc host_data use_device(i, j, i) ! { dg-warning "present on multiple clauses" }
+	!$acc end host_data
+
+	!$acc host_data use_device(p1) ! { dg-error "POINTER" }
+	!$acc end host_data
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/_loop.f95 b/gcc/testsuite/gfortran.dg/gacc/_loop.f95
new file mode 100644
index 00000000000..2c2a2cce7f5
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/_loop.f95
@@ -0,0 +1,171 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fmax-errors=100" } 
+module test
+	implicit none
+contains
+
+subroutine test1  
+	integer :: i, j, k, b(10)
+	integer, dimension (30) :: a
+	double precision :: d
+	real :: r
+	i = 0
+	!$acc loop
+	do 100 ! { dg-error "cannot be a DO WHILE or DO without loop control" }
+		if (i .gt. 0) exit ! { dg-error "EXIT statement" }
+	100 i = i + 1
+	i = 0
+	!$acc loop
+	do ! { dg-error "cannot be a DO WHILE or DO without loop control" }
+	  	if (i .gt. 0) exit ! { dg-error "EXIT statement" }
+	   	i = i + 1
+	end do
+	i = 0
+	!$acc loop
+	do 200 while (i .lt. 4) ! { dg-error "cannot be a DO WHILE or DO without loop control" }
+	200 i = i + 1
+	!$acc loop
+	do while (i .lt. 8) ! { dg-error "cannot be a DO WHILE or DO without loop control" }
+	   	i = i + 1
+	end do
+	!$acc loop
+	do 300 d = 1, 30, 6 ! { dg-error "integer" }
+	  	i = d
+	300 a(i) = 1
+	!$acc loop
+	do d = 1, 30, 5 ! { dg-error "integer" }
+	   	i = d
+	  	a(i) = 2
+	end do
+	!$acc loop
+	do i = 1, 30
+	  	if (i .eq. 16) exit ! { dg-error "EXIT statement" }
+	end do
+	!$acc loop
+	outer: do i = 1, 30
+	    do j = 5, 10
+	      	if (i .eq. 6 .and. j .eq. 7) exit outer ! { dg-error "EXIT statement" }
+	    end do
+	end do outer
+	last: do i = 1, 30
+	 end do last
+
+	! different types of loop are allowed
+	!$acc loop 
+	do i = 1,10
+	end do
+	!$acc loop
+	do 400, i = 1,10
+400 	a(i) = i
+
+	! after loop directive must be loop
+	!$acc loop
+	a(1) = 1 ! { dg-error "Unexpected" }
+	do i = 1,10
+	enddo
+	
+	! combined directives may be used with/without end 
+	!$acc parallel loop
+	do i = 1,10
+	enddo
+	!$acc parallel loop
+	do i = 1,10
+	enddo
+	!$acc end parallel loop
+	!$acc kernels loop
+	do i = 1,10
+	enddo
+	!$acc kernels loop
+	do i = 1,10
+	enddo
+	!$acc end kernels loop
+
+	! reduction clause not allowed in kernels region
+	!$acc kernels loop reduction(max:i) ! { dg-error "KERNELS region" }
+	do i = 1,10
+	enddo
+	!$acc kernels 
+	!$acc loop reduction(max:i) ! { dg-error "KERNELS region" }
+	do i = 1,10
+	enddo
+	!$acc end kernels
+
+	!$acc parallel loop collapse(0) ! { dg-error "constant positive integer" }
+	do i = 1,10
+	enddo
+
+	!$acc parallel loop collapse(-1) ! { dg-error "constant positive integer" }
+	do i = 1,10
+	enddo
+
+	!$acc parallel loop collapse(i) ! { dg-error "Constant expression required" }
+	do i = 1,10
+	enddo
+
+	!$acc parallel loop collapse(4) ! { dg-error "not enough DO loops for collapsed" }
+    do i = 1, 3
+      	do j = 4, 6
+        	do k = 5, 7
+          		a(i+j-k) = i + j + k
+        	end do
+      	end do
+    end do
+  	!$acc parallel loop collapse(2)
+    do i = 1, 5, 2
+      	do j = i + 1, 7, i	! { dg-error "collapsed loops don.t form rectangular iteration space" }
+      	end do
+    end do
+  	!$acc parallel loop collapse(2)
+    do i = 1, 3
+      	do j = 4, 6	
+      	end do
+    end do
+  	!$acc parallel loop collapse(2)
+    do i = 1, 3
+      	do j = 4, 6
+      	end do
+      	k = 4
+    end do
+  	!$acc parallel loop collapse(2)
+    do i = 1, 3
+      	do			! { dg-error "cannot be a DO WHILE or DO without loop control" }
+      	end do
+    end do
+  	!$acc parallel loop collapse(2)
+    do i = 1, 3
+      	do r = 4, 6		! { dg-error "integer" }
+      	end do
+    end do
+
+    ! Both seq and independent are not allowed
+	!$acc loop independent seq ! { dg-error "not allowed" }
+	do i = 1,10
+	enddo
+
+
+	!$acc cache (a(1)) ! { dg-error "inside of loop" }
+
+	do i = 1,10
+		!$acc cache (b) ! { dg-error "single array elements and subarrays" }
+	enddo
+
+	do i = 1,10
+		!$acc cache (a) ! { dg-error "single array elements and subarrays" }
+	enddo
+
+	do i = 1,10
+		!$acc cache (i) ! { dg-error "single array elements and subarrays" }
+	enddo
+
+	do i = 1,10
+		!$acc cache(a(1))
+	enddo
+
+	do i = 1,10
+		a(i) = i
+		!$acc cache(a(1)) 
+	enddo
+
+end subroutine test1
+end module test
+! { dg-excess-errors "Deleted" }
diff --git a/gcc/testsuite/gfortran.dg/gacc/_parallel-kernels-regions.f95 b/gcc/testsuite/gfortran.dg/gacc/_parallel-kernels-regions.f95
new file mode 100644
index 00000000000..7bd44910acf
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/_parallel-kernels-regions.f95
@@ -0,0 +1,55 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc" } 
+
+program test
+	implicit none
+
+	integer :: i
+
+	!$acc parallel
+		!$acc kernels ! { dg-error "parallel or kernels regions" }
+		!$acc end kernels
+	!$acc end parallel
+
+	!$acc parallel
+		!$acc parallel ! { dg-error "parallel or kernels regions" }
+		!$acc end parallel
+	!$acc end parallel
+
+	!$acc parallel
+		!$acc parallel ! { dg-error "parallel or kernels regions" }
+		!$acc end parallel
+		!$acc kernels ! { dg-error "parallel or kernels regions" }
+		!$acc end kernels
+	!$acc end parallel
+
+	!$acc kernels
+		!$acc kernels ! { dg-error "parallel or kernels regions" }
+		!$acc end kernels
+	!$acc end kernels
+
+	!$acc kernels
+		!$acc parallel ! { dg-error "parallel or kernels regions" }
+		!$acc end parallel
+	!$acc end kernels
+
+	!$acc kernels
+		!$acc parallel ! { dg-error "parallel or kernels regions" }
+		!$acc end parallel
+		!$acc kernels ! { dg-error "parallel or kernels regions" }
+		!$acc end kernels
+	!$acc end kernels
+
+	! However, data construct is allowed
+
+	!$acc parallel
+		!$acc data
+		!$acc end data
+	!$acc end parallel
+
+	!$acc kernels
+		!$acc data
+		!$acc end data
+	!$acc end kernels
+	
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/_parallel-tree.f95 b/gcc/testsuite/gfortran.dg/gacc/_parallel-tree.f95
new file mode 100644
index 00000000000..4941f665001
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/_parallel-tree.f95
@@ -0,0 +1,41 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! test for tree-dump-original and spaces-commas
+
+program test
+	implicit none
+	integer :: q, i, j, k, m, n, o, p, r, s, t, u, v, w
+	logical :: l
+
+	!$acc parallel if(l) async num_gangs(i) num_workers(i) vector_length(i) &
+	!$acc reduction(max:q), copy(i), copyin(j), copyout(k), create(m) &
+	!$acc present(o), pcopy(p), pcopyin(r), pcopyout(s), pcreate(t) &
+	!$acc deviceptr(u), private(v), firstprivate(w)
+	!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "pragma acc parallel" "original" } } 
+
+! { dg-final { scan-tree-dump "if" "original" } }
+! { dg-final { scan-tree-dump "async" "original" } } 
+! { dg-final { scan-tree-dump "num_gangs" "original" } } 
+! { dg-final { scan-tree-dump "num_workers" "original" } } 
+! { dg-final { scan-tree-dump "vector_length" "original" } } 
+
+! { dg-final { scan-tree-dump "reduction" "original" } } 
+! { dg-final { scan-tree-dump "copy" "original" } } 
+! { dg-final { scan-tree-dump "copyin" "original" } } 
+! { dg-final { scan-tree-dump "copyout" "original" } } 
+! { dg-final { scan-tree-dump "create" "original" } } 
+
+! { dg-final { scan-tree-dump "present" "original" } } 
+! { dg-final { scan-tree-dump "present_or_copy" "original" } } 
+! { dg-final { scan-tree-dump "present_or_copyin" "original" } } 
+! { dg-final { scan-tree-dump "present_or_copyout" "original" } } 
+! { dg-final { scan-tree-dump "present_or_create" "original" } } 
+
+! { dg-final { scan-tree-dump "deviceptr" "original" } } 
+! { dg-final { scan-tree-dump "private" "original" } } 
+! { dg-final { scan-tree-dump "firstprivate" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/_present_or_copy.f95 b/gcc/testsuite/gfortran.dg/gacc/_present_or_copy.f95
new file mode 100644
index 00000000000..f863b7977f4
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/_present_or_copy.f95
@@ -0,0 +1,22 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+PROGRAM test
+	IMPLICIT NONE
+	INTEGER :: a(10), i, b(10)
+
+	!$ACC DATA copy(b)
+	DO i = 1, 10
+		b(i) = i
+	ENDDO
+	!$ACC PARALLEL
+	!$ACC LOOP
+	DO i = 1, 10
+		a(i) = b(i) ! { dg-warning "present_or_copy" }
+	ENDDO
+	!$ACC END PARALLEL
+
+	!$ACC END DATA
+END
+! { dg-final { scan-tree-dump "present_or_copy" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/_pure-elemental-procedures.f95 b/gcc/testsuite/gfortran.dg/gacc/_pure-elemental-procedures.f95
new file mode 100644
index 00000000000..18495b62271
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/_pure-elemental-procedures.f95
@@ -0,0 +1,46 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc" } 
+
+module test
+	implicit none
+contains
+	elemental subroutine test1
+		!$acc parallel ! { dg-error "may not appear in PURE or ELEMENTAL procedures" }
+	end subroutine test1
+
+	pure subroutine test2
+		!$acc parallel ! { dg-error "may not appear in PURE or ELEMENTAL procedures" }
+	end subroutine test2
+
+	elemental real function test3(x)
+		real, intent(in) :: x
+		!$acc parallel ! { dg-error "may not appear in PURE or ELEMENTAL procedures" }
+		test3 = x
+	end function test3
+
+	pure real function test4(x)
+		real, intent(in) :: x
+		!$acc parallel ! { dg-error "may not appear in PURE or ELEMENTAL procedures" }
+		test4 = x
+	end function test4
+
+	subroutine test5
+		real :: x = 0.0
+		integer :: i
+		!$acc parallel loop collapse(1) reduction(+:x)
+		do i = 1,10
+			x = x + 0.3
+		enddo
+		print *, x
+	end subroutine test5
+
+	real function test6(x)
+		real :: x
+		integer :: i
+		!$acc parallel loop collapse(1) reduction(+:x)
+		do i = 1,10
+			x = x + 0.3
+		enddo
+		test6 = x
+	end function test6
+end module test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/_reduction.f95 b/gcc/testsuite/gfortran.dg/gacc/_reduction.f95
new file mode 100644
index 00000000000..5de892c86a5
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/_reduction.f95
@@ -0,0 +1,128 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fmax-errors=100" } 
+
+subroutine foo (ia1)
+integer :: i1, i2, i3
+integer, dimension (*) :: ia1
+integer, dimension (10) :: ia2
+real :: r1
+real, dimension (5) :: ra1
+double precision :: d1
+double precision, dimension (4) :: da1
+complex :: c1
+complex, dimension (7) :: ca1
+logical :: l1
+logical, dimension (3) :: la1
+character (5) :: a1
+type t
+  integer :: i
+end type
+type(t) :: t1
+type(t), dimension (2) :: ta1
+real, pointer :: p1 => NULL()
+integer, allocatable :: aa1 (:,:)
+save i2
+common /blk/ i1
+
+!$acc parallel reduction (+:i3, ia2, r1, ra1, d1, da1, c1, ca1)
+!$acc end parallel
+!$acc parallel reduction (*:i3, ia2, r1, ra1, d1, da1, c1, ca1)
+!$acc end parallel
+!$acc parallel reduction (-:i3, ia2, r1, ra1, d1, da1, c1, ca1)
+!$acc end parallel
+!$acc parallel reduction (.and.:l1, la1)
+!$acc end parallel
+!$acc parallel reduction (.or.:l1, la1)
+!$acc end parallel
+!$acc parallel reduction (.eqv.:l1, la1)
+!$acc end parallel
+!$acc parallel reduction (.neqv.:l1, la1)
+!$acc end parallel
+!$acc parallel reduction (min:i3, ia2, r1, ra1, d1, da1)
+!$acc end parallel
+!$acc parallel reduction (max:i3, ia2, r1, ra1, d1, da1)
+!$acc end parallel
+!$acc parallel reduction (iand:i3, ia2)
+!$acc end parallel
+!$acc parallel reduction (ior:i3, ia2)
+!$acc end parallel
+!$acc parallel reduction (ieor:i3, ia2)
+!$acc end parallel
+!$acc parallel reduction (+:/blk/)	! { dg-error "Syntax error" }
+!$acc end parallel			! { dg-error "Unexpected" }
+!$acc parallel reduction (*:p1)		! { dg-error "POINTER object" }
+!$acc end parallel
+!$acc parallel reduction (-:aa1)
+!$acc end parallel
+!$acc parallel reduction (*:ia1)	! { dg-error "Assumed size" }
+!$acc end parallel
+!$acc parallel reduction (+:l1)		! { dg-error "must be of numeric type, got LOGICAL" }
+!$acc end parallel
+!$acc parallel reduction (*:la1)	! { dg-error "must be of numeric type, got LOGICAL" }
+!$acc end parallel
+!$acc parallel reduction (-:a1)		! { dg-error "must be of numeric type, got CHARACTER" }
+!$acc end parallel
+!$acc parallel reduction (+:t1)		! { dg-error "must be of numeric type, got TYPE" }
+!$acc end parallel
+!$acc parallel reduction (*:ta1)	! { dg-error "must be of numeric type, got TYPE" }
+!$acc end parallel
+!$acc parallel reduction (.and.:i3)	! { dg-error "must be LOGICAL" }
+!$acc end parallel
+!$acc parallel reduction (.or.:ia2)	! { dg-error "must be LOGICAL" }
+!$acc end parallel
+!$acc parallel reduction (.eqv.:r1)	! { dg-error "must be LOGICAL" }
+!$acc end parallel
+!$acc parallel reduction (.neqv.:ra1)	! { dg-error "must be LOGICAL" }
+!$acc end parallel
+!$acc parallel reduction (.and.:d1)	! { dg-error "must be LOGICAL" }
+!$acc end parallel
+!$acc parallel reduction (.or.:da1)	! { dg-error "must be LOGICAL" }
+!$acc end parallel
+!$acc parallel reduction (.eqv.:c1)	! { dg-error "must be LOGICAL" }
+!$acc end parallel
+!$acc parallel reduction (.neqv.:ca1)	! { dg-error "must be LOGICAL" }
+!$acc end parallel
+!$acc parallel reduction (.and.:a1)	! { dg-error "must be LOGICAL" }
+!$acc end parallel
+!$acc parallel reduction (.or.:t1)	! { dg-error "must be LOGICAL" }
+!$acc end parallel
+!$acc parallel reduction (.eqv.:ta1)	! { dg-error "must be LOGICAL" }
+!$acc end parallel
+!$acc parallel reduction (min:c1)	! { dg-error "must be INTEGER or REAL" }
+!$acc end parallel
+!$acc parallel reduction (max:ca1)	! { dg-error "must be INTEGER or REAL" }
+!$acc end parallel
+!$acc parallel reduction (max:l1)	! { dg-error "must be INTEGER or REAL" }
+!$acc end parallel
+!$acc parallel reduction (min:la1)	! { dg-error "must be INTEGER or REAL" }
+!$acc end parallel
+!$acc parallel reduction (max:a1)	! { dg-error "must be INTEGER or REAL" }
+!$acc end parallel
+!$acc parallel reduction (min:t1)	! { dg-error "must be INTEGER or REAL" }
+!$acc end parallel
+!$acc parallel reduction (max:ta1)	! { dg-error "must be INTEGER or REAL" }
+!$acc end parallel
+!$acc parallel reduction (iand:r1)	! { dg-error "must be INTEGER" }
+!$acc end parallel
+!$acc parallel reduction (ior:ra1)	! { dg-error "must be INTEGER" }
+!$acc end parallel
+!$acc parallel reduction (ieor:d1)	! { dg-error "must be INTEGER" }
+!$acc end parallel
+!$acc parallel reduction (ior:da1)	! { dg-error "must be INTEGER" }
+!$acc end parallel
+!$acc parallel reduction (iand:c1)	! { dg-error "must be INTEGER" }
+!$acc end parallel
+!$acc parallel reduction (ior:ca1)	! { dg-error "must be INTEGER" }
+!$acc end parallel
+!$acc parallel reduction (ieor:l1)	! { dg-error "must be INTEGER" }
+!$acc end parallel
+!$acc parallel reduction (iand:la1)	! { dg-error "must be INTEGER" }
+!$acc end parallel
+!$acc parallel reduction (ior:a1)	! { dg-error "must be INTEGER" }
+!$acc end parallel
+!$acc parallel reduction (ieor:t1)	! { dg-error "must be INTEGER" }
+!$acc end parallel
+!$acc parallel reduction (iand:ta1)	! { dg-error "must be INTEGER" }
+!$acc end parallel
+
+end subroutine
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/_sentinel-free-form.f95 b/gcc/testsuite/gfortran.dg/gacc/_sentinel-free-form.f95
new file mode 100644
index 00000000000..04c67d5a15e
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/_sentinel-free-form.f95
@@ -0,0 +1,22 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc" } 
+
+program test
+	implicit none
+
+	integer :: i
+	real :: x
+
+	! sentinel may only be preceeded by white space
+	x = 0.0 !$acc parallel ! comment
+	! sentinel must appear as a single word
+	! $acc parallel ! comment
+	!$ acc parallel ! { dg-error "Unclassifiable statement" }
+	! directive lines must have space after sentinel
+	!$accparallel ! { dg-warning "followed by a space" }
+	do i = 1,10
+		x = x + 0.3
+	enddo
+	!$acc end parallel ! { dg-error "Unexpected" }
+	print *, x
+end
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/_several-directives.f95 b/gcc/testsuite/gfortran.dg/gacc/_several-directives.f95
new file mode 100644
index 00000000000..7e1d0f9b2e0
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/_several-directives.f95
@@ -0,0 +1,7 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc" } 
+
+program test
+	! only one directive-name may appear in directive
+	!$acc parallel kernels ! { dg-error "Unclassifiable OpenACC directive" }
+end
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/_sie.f95 b/gcc/testsuite/gfortran.dg/gacc/_sie.f95
new file mode 100644
index 00000000000..2be37244d4c
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/_sie.f95
@@ -0,0 +1,252 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fmax-errors=100" } 
+
+! tests async, num_gangs, num_workers, vector_length, gang, worker, vector clauses
+
+program test
+	implicit none
+
+	integer :: i
+
+	!$acc parallel async
+	!$acc end parallel
+
+	!$acc parallel async(3)
+	!$acc end parallel
+
+	!$acc parallel async(i)
+	!$acc end parallel
+
+	!$acc parallel async(i+1)
+	!$acc end parallel
+
+	!$acc parallel async(-1) ! { dg-warning "must be positive" }
+	!$acc end parallel
+
+	!$acc parallel async(0) ! { dg-warning "must be positive" }
+	!$acc end parallel
+
+	!$acc parallel async() ! { dg-error "Invalid character in name" }
+
+	!$acc parallel async(1.5) ! { dg-error "scalar INTEGER expression" }
+	!$acc end parallel
+
+	!$acc parallel async(.true.) ! { dg-error "scalar INTEGER expression" }
+	!$acc end parallel
+
+	!$acc parallel async("1") ! { dg-error "scalar INTEGER expression" }
+	!$acc end parallel
+
+	!$acc kernels async
+	!$acc end kernels
+
+	!$acc kernels async(3)
+	!$acc end kernels
+
+	!$acc kernels async(i)
+	!$acc end kernels
+
+	!$acc kernels async(i+1)
+	!$acc end kernels
+
+	!$acc kernels async(-1) ! { dg-warning "must be positive" }
+	!$acc end kernels
+
+	!$acc kernels async(0) ! { dg-warning "must be positive" }
+	!$acc end kernels
+
+	!$acc kernels async() ! { dg-error "Invalid character in name" }
+
+	!$acc kernels async(1.5) ! { dg-error "scalar INTEGER expression" }
+	!$acc end kernels
+
+	!$acc kernels async(.true.) ! { dg-error "scalar INTEGER expression" }
+	!$acc end kernels
+
+	!$acc kernels async("1") ! { dg-error "scalar INTEGER expression" }
+	!$acc end kernels
+
+
+	!$acc parallel num_gangs ! { dg-error "Unclassifiable OpenACC directive" }
+
+	!$acc parallel num_gangs(3)
+	!$acc end parallel
+
+	!$acc parallel num_gangs(i)
+	!$acc end parallel
+
+	!$acc parallel num_gangs(i+1)
+	!$acc end parallel
+
+	!$acc parallel num_gangs(-1) ! { dg-warning "must be positive" }
+	!$acc end parallel
+
+	!$acc parallel num_gangs(0) ! { dg-warning "must be positive" }
+	!$acc end parallel
+
+	!$acc parallel num_gangs() ! { dg-error "Invalid character in name" }
+
+	!$acc parallel num_gangs(1.5) ! { dg-error "scalar INTEGER expression" }
+	!$acc end parallel
+
+	!$acc parallel num_gangs(.true.) ! { dg-error "scalar INTEGER expression" }
+	!$acc end parallel
+
+	!$acc parallel num_gangs("1") ! { dg-error "scalar INTEGER expression" }
+	!$acc end parallel
+
+
+	!$acc parallel num_workers ! { dg-error "Unclassifiable OpenACC directive" }
+
+	!$acc parallel num_workers(3)
+	!$acc end parallel
+
+	!$acc parallel num_workers(i)
+	!$acc end parallel
+
+	!$acc parallel num_workers(i+1)
+	!$acc end parallel
+
+	!$acc parallel num_workers(-1) ! { dg-warning "must be positive" }
+	!$acc end parallel
+
+	!$acc parallel num_workers(0) ! { dg-warning "must be positive" }
+	!$acc end parallel
+
+	!$acc parallel num_workers() ! { dg-error "Invalid character in name" }
+
+	!$acc parallel num_workers(1.5) ! { dg-error "scalar INTEGER expression" }
+	!$acc end parallel
+
+	!$acc parallel num_workers(.true.) ! { dg-error "scalar INTEGER expression" }
+	!$acc end parallel
+
+	!$acc parallel num_workers("1") ! { dg-error "scalar INTEGER expression" }
+	!$acc end parallel
+
+
+	!$acc parallel vector_length ! { dg-error "Unclassifiable OpenACC directive" }
+
+	!$acc parallel vector_length(3)
+	!$acc end parallel
+
+	!$acc parallel vector_length(i)
+	!$acc end parallel
+
+	!$acc parallel vector_length(i+1)
+	!$acc end parallel
+
+	!$acc parallel vector_length(-1) ! { dg-warning "must be positive" }
+	!$acc end parallel
+
+	!$acc parallel vector_length(0) ! { dg-warning "must be positive" }
+	!$acc end parallel
+
+	!$acc parallel vector_length() ! { dg-error "Invalid character in name" }
+
+	!$acc parallel vector_length(1.5) ! { dg-error "scalar INTEGER expression" }
+	!$acc end parallel
+
+	!$acc parallel vector_length(.true.) ! { dg-error "scalar INTEGER expression" }
+	!$acc end parallel
+
+	!$acc parallel vector_length("1") ! { dg-error "scalar INTEGER expression" }
+	!$acc end parallel
+
+
+	!$acc loop gang
+	do i = 1,10
+	enddo
+	!$acc loop gang(3)
+	do i = 1,10
+	enddo
+	!$acc loop gang(i)
+	do i = 1,10
+	enddo
+	!$acc loop gang(i+1)
+	do i = 1,10
+	enddo
+	!$acc loop gang(-1) ! { dg-warning "must be positive" }
+	do i = 1,10
+	enddo
+	!$acc loop gang(0) ! { dg-warning "must be positive" }
+	do i = 1,10
+	enddo
+	!$acc loop gang() ! { dg-error "Invalid character in name" }
+	do i = 1,10
+	enddo
+	!$acc loop gang(1.5) ! { dg-error "scalar INTEGER expression" }
+	do i = 1,10
+	enddo
+	!$acc loop gang(.true.) ! { dg-error "scalar INTEGER expression" }
+	do i = 1,10
+	enddo
+	!$acc loop gang("1") ! { dg-error "scalar INTEGER expression" }
+	do i = 1,10
+	enddo
+
+
+	!$acc loop worker
+	do i = 1,10
+	enddo
+	!$acc loop worker(3)
+	do i = 1,10
+	enddo
+	!$acc loop worker(i)
+	do i = 1,10
+	enddo
+	!$acc loop worker(i+1)
+	do i = 1,10
+	enddo
+	!$acc loop worker(-1) ! { dg-warning "must be positive" }
+	do i = 1,10
+	enddo
+	!$acc loop worker(0) ! { dg-warning "must be positive" }
+	do i = 1,10
+	enddo
+	!$acc loop worker() ! { dg-error "Invalid character in name" }
+	do i = 1,10
+	enddo
+	!$acc loop worker(1.5) ! { dg-error "scalar INTEGER expression" }
+	do i = 1,10
+	enddo
+	!$acc loop worker(.true.) ! { dg-error "scalar INTEGER expression" }
+	do i = 1,10
+	enddo
+	!$acc loop worker("1") ! { dg-error "scalar INTEGER expression" }
+	do i = 1,10
+	enddo
+
+
+	!$acc loop vector
+	do i = 1,10
+	enddo
+	!$acc loop vector(3)
+	do i = 1,10
+	enddo
+	!$acc loop vector(i)
+	do i = 1,10
+	enddo
+	!$acc loop vector(i+1)
+	do i = 1,10
+	enddo
+	!$acc loop vector(-1) ! { dg-warning "must be positive" }
+	do i = 1,10
+	enddo
+	!$acc loop vector(0) ! { dg-warning "must be positive" }
+	do i = 1,10
+	enddo
+	!$acc loop vector() ! { dg-error "Invalid character in name" }
+	do i = 1,10
+	enddo
+	!$acc loop vector(1.5) ! { dg-error "scalar INTEGER expression" }
+	do i = 1,10
+	enddo
+	!$acc loop vector(.true.) ! { dg-error "scalar INTEGER expression" }
+	do i = 1,10
+	enddo
+	!$acc loop vector("1") ! { dg-error "scalar INTEGER expression" }
+	do i = 1,10
+	enddo
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/_subarrays.f95 b/gcc/testsuite/gfortran.dg/gacc/_subarrays.f95
new file mode 100644
index 00000000000..7b2f0211e7a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/_subarrays.f95
@@ -0,0 +1,37 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc" } 
+program test
+	implicit none
+	integer :: a(10), b(10, 10), c(3:7), i
+
+	!$acc parallel copy(a(1:5))
+	!$acc end parallel
+	!$acc parallel copy(a(1 + 0 : 5 + 2))
+	!$acc end parallel
+	!$acc parallel copy(a(:3))
+	!$acc end parallel
+	!$acc parallel copy(a(3:))
+	!$acc end parallel
+	!$acc parallel copy(a(:)) ! { dg-error "Syntax error in OpenACC variable list" }
+	!$acc parallel copy(a(2:3,2:3)) ! { dg-error "Number of dimensions" }
+	!$acc end parallel
+	! TODO: there must be warning
+	!$acc parallel copy (a(:11))
+	!$acc end parallel
+	!$acc parallel copy (a(i:))
+	!$acc end parallel
+
+	!$acc parallel copy (a(:b)) ! { dg-error "scalar INTEGER expression" }
+	!$acc end parallel
+
+	!$acc parallel copy (b(1:3,2:4))
+	!$acc end parallel 
+	!$acc parallel copy (b(2:3)) ! { dg-error "Number of dimensions" }
+	!$acc end parallel
+	!$acc parallel copy (b(1:, 4:6)) ! { dg-warning "whole dimension" }
+	!$acc end parallel
+
+	! TODO: there must be warning
+	!$acc parallel copy (c(2:))
+	!$acc end parallel
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/async-double_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/async-double_xfail.f95
new file mode 100644
index 00000000000..13d946cad05
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/async-double_xfail.f95
@@ -0,0 +1,29 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc update async (1.5) ! { dg-error "requires a scalar INTEGER expression" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc parallel async (1.5) ! { dg-error "requires a scalar INTEGER expression" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels async (1.5) ! { dg-error "requires a scalar INTEGER expression" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/async-empty.f95 b/gcc/testsuite/gfortran.dg/gacc/async-empty.f95
new file mode 100644
index 00000000000..1365142e4b8
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/async-empty.f95
@@ -0,0 +1,34 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc update async  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc parallel async  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels async  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "update" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "async" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/async-identifier.f95 b/gcc/testsuite/gfortran.dg/gacc/async-identifier.f95
new file mode 100644
index 00000000000..342d1e24961
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/async-identifier.f95
@@ -0,0 +1,34 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc update async (x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc parallel async (x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels async (x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "update" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "async" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/async-integer-literal.f95 b/gcc/testsuite/gfortran.dg/gacc/async-integer-literal.f95
new file mode 100644
index 00000000000..28c240855ea
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/async-integer-literal.f95
@@ -0,0 +1,34 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc update async (10) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc parallel async (10) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels async (10) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "update" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "async" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/async-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/async-pointer.f95
new file mode 100644
index 00000000000..906be3860bd
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/async-pointer.f95
@@ -0,0 +1,37 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+	integer, pointer :: y
+	integer, target :: x2 = 4
+	y => x2
+
+!$acc update async (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc parallel async (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels async (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "update" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "async" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/cache-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/cache-array-pointer.f95
new file mode 100644
index 00000000000..3d2abeced2a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/cache-array-pointer.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc cache (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
+! { dg-final { scan-tree-dump "cache" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/cache-cache-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/cache-cache-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..3a2ab9ad57a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/cache-cache-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc cache (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/cache-cache-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/cache-cache-empty-list_xfail.f95
new file mode 100644
index 00000000000..717f594ec51
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/cache-cache-empty-list_xfail.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc cache () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/cache-cache-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/cache-cache-empty_xfail.f95
new file mode 100644
index 00000000000..335dc3f8d53
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/cache-cache-empty_xfail.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc cache  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/cache-cache-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/cache-cache-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..78035aeb29c
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/cache-cache-identifiers-without-comma_xfail.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc cache (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/cache-identifier-and-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/cache-identifier-and-array-pointer.f95
new file mode 100644
index 00000000000..8ad34892090
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/cache-identifier-and-array-pointer.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc cache (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
+! { dg-final { scan-tree-dump "cache" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/cache-identifiers.f95 b/gcc/testsuite/gfortran.dg/gacc/cache-identifiers.f95
new file mode 100644
index 00000000000..ed8c360911d
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/cache-identifiers.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc cache (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
+! { dg-final { scan-tree-dump "cache" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/cache-integer-literal-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/cache-integer-literal-and-identifier_xfail.f95
new file mode 100644
index 00000000000..e5054bec1fe
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/cache-integer-literal-and-identifier_xfail.f95
@@ -0,0 +1,15 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc cache (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/cache-integer-literal_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/cache-integer-literal_xfail.f95
new file mode 100644
index 00000000000..935ae1b0db2
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/cache-integer-literal_xfail.f95
@@ -0,0 +1,15 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc cache (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/cache-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/cache-pointer.f95
new file mode 100644
index 00000000000..d38458536ac
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/cache-pointer.f95
@@ -0,0 +1,20 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+	integer, pointer :: y
+	integer, target :: x2 = 4
+	y => x2
+
+!$acc cache (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
+! { dg-final { scan-tree-dump "cache" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/collapse-double_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/collapse-double_xfail.f95
new file mode 100644
index 00000000000..e67c3580ec0
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/collapse-double_xfail.f95
@@ -0,0 +1,39 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop collapse (1.5) ! { dg-error "Integer expression required" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop collapse (1.5) ! { dg-error "Integer expression required" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel   
+!$acc loop collapse (1.5) ! { dg-error "Integer expression required" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop collapse (1.5) ! { dg-error "Integer expression required" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/collapse-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/collapse-identifier_xfail.f95
new file mode 100644
index 00000000000..b1342f8ec45
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/collapse-identifier_xfail.f95
@@ -0,0 +1,47 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer :: i, j
+	integer :: x = 2, x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop collapse (x) ! { dg-error "Constant expression required" } 
+	do i = 1,10
+		do j = 1,2
+			x1 = x1 + 1
+			a1(i) = x1
+		enddo
+	end do
+!$acc end kernels
+
+!$acc kernels loop collapse (x) ! { dg-error "Constant expression required" } 
+	do i = 1,10
+		do j=1,2
+			x1 = x1 + 1
+			a1(i) = x1
+		enddo
+	end do
+!$acc end kernels loop
+
+!$acc parallel   
+!$acc loop collapse (x)  ! { dg-error "Constant expression required" } 
+	do i = 1,10
+		do j = 1,2
+			x1 = x1 + 1
+			a1(i) = x1
+		enddo
+	end do
+!$acc end parallel
+
+!$acc parallel loop collapse (x)  ! { dg-error "Constant expression required" } 
+	do i = 1,10
+		do j = 1,2
+			x1 = x1 + 1
+			a1(i) = x1
+		enddo
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/collapse-integer-literal.f95 b/gcc/testsuite/gfortran.dg/gacc/collapse-integer-literal.f95
new file mode 100644
index 00000000000..ea49cb80f48
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/collapse-integer-literal.f95
@@ -0,0 +1,52 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer :: i, j
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop collapse (2) 
+	do i = 1,10
+		do j = 1,2
+			x1 = x1 + 1
+			a1(i) = x1
+		enddo
+	end do
+!$acc end kernels
+
+!$acc kernels loop collapse (2) 
+	do i = 1,10
+		do j = 1,2
+			x1 = x1 + 1
+			a1(i) = x1
+		enddo
+	end do
+!$acc end kernels loop
+
+!$acc parallel   
+!$acc loop collapse (2) 
+	do i = 1,10
+		do j = 1,2
+			x1 = x1 + 1
+			a1(i) = x1
+		enddo
+	end do
+!$acc end parallel
+
+!$acc parallel loop collapse (2) 
+	do i = 1,10
+		do j = 1,2
+			x1 = x1 + 1
+			a1(i) = x1
+		enddo
+	end do
+!$acc end parallel loop
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "collapse" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/collapse-pointer_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/collapse-pointer_xfail.f95
new file mode 100644
index 00000000000..6161845a800
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/collapse-pointer_xfail.f95
@@ -0,0 +1,44 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+	integer, pointer :: y
+	integer, target :: x2 = 4
+	y => x2
+
+!$acc kernels   
+!$acc loop collapse (y) ! { gd-error "Constant expression required" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop collapse (y) ! { gd-error "Constant expression required" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel   
+!$acc loop collapse (y) ! { gd-error "Constant expression required" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop collapse (y) ! { gd-error "Constant expression required" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/copy-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/copy-array-pointer.f95
new file mode 100644
index 00000000000..e531f7da687
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/copy-array-pointer.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data copy (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel copy (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels copy (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "copy" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/copy-identifier-and-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/copy-identifier-and-array-pointer.f95
new file mode 100644
index 00000000000..4d402771b29
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/copy-identifier-and-array-pointer.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data copy (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel copy (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels copy (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "copy" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/copy-identifiers.f95 b/gcc/testsuite/gfortran.dg/gacc/copy-identifiers.f95
new file mode 100644
index 00000000000..bef2b2c58df
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/copy-identifiers.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data copy (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel copy (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels copy (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "copy" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/copy-integer-literal-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/copy-integer-literal-and-identifier_xfail.f95
new file mode 100644
index 00000000000..fdca6732408
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/copy-integer-literal-and-identifier_xfail.f95
@@ -0,0 +1,27 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data copy (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc parallel copy (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc kernels copy (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/copy-integer-literal_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/copy-integer-literal_xfail.f95
new file mode 100644
index 00000000000..cff3b904b41
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/copy-integer-literal_xfail.f95
@@ -0,0 +1,27 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data copy (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc parallel copy (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc kernels copy (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/copy-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/copy-pointer.f95
new file mode 100644
index 00000000000..3d42fab109d
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/copy-pointer.f95
@@ -0,0 +1,38 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+	integer, pointer :: y
+	integer, target :: x2 = 4
+	y => x2
+
+!$acc data copy (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel copy (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels copy (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "copy" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/copyin-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/copyin-array-pointer.f95
new file mode 100644
index 00000000000..d254d062583
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/copyin-array-pointer.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data copyin (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel copyin (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels copyin (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "copyin" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/copyin-identifier-and-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/copyin-identifier-and-array-pointer.f95
new file mode 100644
index 00000000000..a2cb43f2029
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/copyin-identifier-and-array-pointer.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data copyin (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel copyin (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels copyin (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "copyin" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/copyin-identifiers.f95 b/gcc/testsuite/gfortran.dg/gacc/copyin-identifiers.f95
new file mode 100644
index 00000000000..be2e47ef598
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/copyin-identifiers.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data copyin (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel copyin (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels copyin (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "copyin" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/copyin-integer-literal-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/copyin-integer-literal-and-identifier_xfail.f95
new file mode 100644
index 00000000000..ebd98a7c8e6
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/copyin-integer-literal-and-identifier_xfail.f95
@@ -0,0 +1,32 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data copyin (10, x1)  ! { gd-error "Syntax error in OpenACC variable list" } 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel copyin (10, x1)  ! { gd-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels copyin (10, x1) ! { gd-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/copyin-integer-literal_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/copyin-integer-literal_xfail.f95
new file mode 100644
index 00000000000..df5ecb38fa8
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/copyin-integer-literal_xfail.f95
@@ -0,0 +1,32 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data copyin (10) ! { gd-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel copyin (10) ! { gd-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels copyin (10) ! { gd-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/copyin-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/copyin-pointer.f95
new file mode 100644
index 00000000000..ae8302ac412
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/copyin-pointer.f95
@@ -0,0 +1,38 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+	integer, pointer :: y
+	integer, target :: x2 = 4
+	y => x2
+
+!$acc data copyin (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel copyin (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels copyin (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "copyin" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/copyout-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/copyout-array-pointer.f95
new file mode 100644
index 00000000000..da238668cad
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/copyout-array-pointer.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data copyout (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel copyout (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels copyout (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "copyout" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/copyout-identifier-and-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/copyout-identifier-and-array-pointer.f95
new file mode 100644
index 00000000000..4a5f80cdc19
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/copyout-identifier-and-array-pointer.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data copyout (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel copyout (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels copyout (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "copyout" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/copyout-identifiers.f95 b/gcc/testsuite/gfortran.dg/gacc/copyout-identifiers.f95
new file mode 100644
index 00000000000..21164768330
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/copyout-identifiers.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data copyout (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel copyout (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels copyout (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "copyout" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/copyout-integer-literal-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/copyout-integer-literal-and-identifier_xfail.f95
new file mode 100644
index 00000000000..bb69b62b7e4
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/copyout-integer-literal-and-identifier_xfail.f95
@@ -0,0 +1,32 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data copyout (10, x1) ! { gd-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel copyout (10, x1) ! { gd-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels copyout (10, x1) ! { gd-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/copyout-integer-literal_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/copyout-integer-literal_xfail.f95
new file mode 100644
index 00000000000..bbc9d277158
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/copyout-integer-literal_xfail.f95
@@ -0,0 +1,32 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data copyout (10) ! { gd-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel copyout (10) ! { gd-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels copyout (10) ! { gd-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/copyout-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/copyout-pointer.f95
new file mode 100644
index 00000000000..cc09d6bf468
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/copyout-pointer.f95
@@ -0,0 +1,38 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+	integer, pointer :: y
+	integer, target :: x2 = 4
+	y => x2
+
+!$acc data copyout (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel copyout (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels copyout (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "copyout" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/create-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/create-array-pointer.f95
new file mode 100644
index 00000000000..cf542c55cd5
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/create-array-pointer.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data create (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel create (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels create (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "create" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/create-identifier-and-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/create-identifier-and-array-pointer.f95
new file mode 100644
index 00000000000..106540b0867
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/create-identifier-and-array-pointer.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data create (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel create (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels create (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "create" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/create-identifiers.f95 b/gcc/testsuite/gfortran.dg/gacc/create-identifiers.f95
new file mode 100644
index 00000000000..72788683a32
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/create-identifiers.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data create (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel create (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels create (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "create" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/create-integer-literal-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/create-integer-literal-and-identifier_xfail.f95
new file mode 100644
index 00000000000..d01dda26179
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/create-integer-literal-and-identifier_xfail.f95
@@ -0,0 +1,27 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data create (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc parallel create (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc kernels create (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/create-integer-literal_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/create-integer-literal_xfail.f95
new file mode 100644
index 00000000000..7c8c753fb4a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/create-integer-literal_xfail.f95
@@ -0,0 +1,27 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data create (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc parallel create (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc kernels create (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/create-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/create-pointer.f95
new file mode 100644
index 00000000000..cf8a7ddefdc
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/create-pointer.f95
@@ -0,0 +1,38 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+	integer, pointer :: y
+	integer, target :: x2 = 4
+	y => x2
+
+!$acc data create (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel create (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels create (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "create" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-copy-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-copy-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..e3546525df1
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-copy-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data copy (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-copy-array-without-semocolon-and-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-copy-array-without-semocolon-and-limits_xfail.f95
new file mode 100644
index 00000000000..fe1b524f8db
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-copy-array-without-semocolon-and-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data copy (a1()) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-copy-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-copy-empty-list_xfail.f95
new file mode 100644
index 00000000000..1cd6f3f7ed4
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-copy-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data copy () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-copy-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-copy-empty_xfail.f95
new file mode 100644
index 00000000000..b2e3f5147c4
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-copy-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data copy  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-copy-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-copy-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..72b01db58a6
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-copy-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data copy (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-copyin-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-copyin-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..a1d18bce70e
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-copyin-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data copyin (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-copyin-array-without-semocolon-and-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-copyin-array-without-semocolon-and-limits_xfail.f95
new file mode 100644
index 00000000000..b9adc1950fd
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-copyin-array-without-semocolon-and-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data copyin (a1()) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-copyin-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-copyin-empty-list_xfail.f95
new file mode 100644
index 00000000000..f61559cd80b
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-copyin-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data copyin () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-copyin-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-copyin-empty_xfail.f95
new file mode 100644
index 00000000000..1ab49160700
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-copyin-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data copyin  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-copyin-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-copyin-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..d5535ab055f
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-copyin-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data copyin (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-copyout-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-copyout-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..c1c57ee7bf4
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-copyout-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data copyout (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-copyout-array-without-semocolon-and-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-copyout-array-without-semocolon-and-limits_xfail.f95
new file mode 100644
index 00000000000..440baf5aec9
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-copyout-array-without-semocolon-and-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data copyout (a1()) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-copyout-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-copyout-empty-list_xfail.f95
new file mode 100644
index 00000000000..71325456b8c
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-copyout-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data copyout () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-copyout-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-copyout-empty_xfail.f95
new file mode 100644
index 00000000000..4643554316c
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-copyout-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data copyout  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-copyout-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-copyout-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..2e05df152fd
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-copyout-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data copyout (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-create-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-create-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..141c81d69c6
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-create-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data create (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-create-array-without-semocolon-and-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-create-array-without-semocolon-and-limits_xfail.f95
new file mode 100644
index 00000000000..42903801148
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-create-array-without-semocolon-and-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data create (a1()) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-create-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-create-empty-list_xfail.f95
new file mode 100644
index 00000000000..1fcd5c505c9
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-create-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data create () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-create-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-create-empty_xfail.f95
new file mode 100644
index 00000000000..d4343194c99
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-create-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data create  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-create-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-create-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..a52faabe60d
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-create-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data create (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-deviceptr-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-deviceptr-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..ddd58b66d39
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-deviceptr-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data deviceptr (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-deviceptr-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-deviceptr-empty-list_xfail.f95
new file mode 100644
index 00000000000..e9f28ff103e
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-deviceptr-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data deviceptr () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-deviceptr-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-deviceptr-empty_xfail.f95
new file mode 100644
index 00000000000..37c14c03e8b
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-deviceptr-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data deviceptr  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-deviceptr-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-deviceptr-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..cbf1d0df444
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-deviceptr-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data deviceptr (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-deviceptr-integer-literal-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-deviceptr-integer-literal-and-identifier_xfail.f95
new file mode 100644
index 00000000000..60364bd30aa
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-deviceptr-integer-literal-and-identifier_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data deviceptr (10, x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-deviceptr-integer-literal_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-deviceptr-integer-literal_xfail.f95
new file mode 100644
index 00000000000..851ac505dc1
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-deviceptr-integer-literal_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data deviceptr (10) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-if-array-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-if-array-limits_xfail.f95
new file mode 100644
index 00000000000..9187fc96d41
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-if-array-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data if (a1(2:5)) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-if-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-if-empty_xfail.f95
new file mode 100644
index 00000000000..b5c25245c32
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-if-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data if  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-if-expresion-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-if-expresion-without-bracket_xfail.f95
new file mode 100644
index 00000000000..2a27163685c
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-if-expresion-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data if (1 == 0 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-if-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-if-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..96a7e61ac88
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-if-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data if 1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-if-white-space_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-if-white-space_xfail.f95
new file mode 100644
index 00000000000..e9d66c7417f
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-if-white-space_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data if () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-present-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-present-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..9181c3ed7cc
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-present-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-present-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-present-empty-list_xfail.f95
new file mode 100644
index 00000000000..a7ad858a5be
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-present-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-present-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-present-empty_xfail.f95
new file mode 100644
index 00000000000..c71110d1c61
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-present-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-present-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-present-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..cb2dbb8106a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-present-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data present (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-present_or_copy-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copy-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..fa1c152dfdd
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copy-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_copy (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-present_or_copy-array-without-semocolon-and-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copy-array-without-semocolon-and-limits_xfail.f95
new file mode 100644
index 00000000000..05966006c7b
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copy-array-without-semocolon-and-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_copy (a1()) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-present_or_copy-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copy-empty-list_xfail.f95
new file mode 100644
index 00000000000..229a5bf5bac
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copy-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_copy () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-present_or_copy-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copy-empty_xfail.f95
new file mode 100644
index 00000000000..d91dfc59896
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copy-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_copy  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-present_or_copy-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copy-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..26821439ba2
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copy-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data present_or_copy (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyin-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyin-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..e9b3a69487c
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyin-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_copyin (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyin-array-without-semocolon-and-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyin-array-without-semocolon-and-limits_xfail.f95
new file mode 100644
index 00000000000..5d659b2cce3
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyin-array-without-semocolon-and-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_copyin (a1()) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyin-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyin-empty-list_xfail.f95
new file mode 100644
index 00000000000..9d9e15fb89f
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyin-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_copyin () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyin-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyin-empty_xfail.f95
new file mode 100644
index 00000000000..636e0b171dd
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyin-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_copyin  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyin-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyin-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..994343d3274
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyin-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data present_or_copyin (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyout-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyout-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..e91546e793b
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyout-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_copyout (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyout-array-without-semocolon-and-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyout-array-without-semocolon-and-limits_xfail.f95
new file mode 100644
index 00000000000..e7239d8f389
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyout-array-without-semocolon-and-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_copyout (a1()) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyout-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyout-empty-list_xfail.f95
new file mode 100644
index 00000000000..1566f67cf68
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyout-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_copyout () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyout-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyout-empty_xfail.f95
new file mode 100644
index 00000000000..7c20d6bc13e
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyout-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_copyout  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyout-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyout-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..968edb0e380
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-present_or_copyout-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data present_or_copyout (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-present_or_create-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-present_or_create-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..c955b393997
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-present_or_create-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_create (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-present_or_create-array-without-semocolon-and-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-present_or_create-array-without-semocolon-and-limits_xfail.f95
new file mode 100644
index 00000000000..9cda10112a2
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-present_or_create-array-without-semocolon-and-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_create (a1()) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-present_or_create-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-present_or_create-empty-list_xfail.f95
new file mode 100644
index 00000000000..0e63de80de7
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-present_or_create-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_create () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-present_or_create-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-present_or_create-empty_xfail.f95
new file mode 100644
index 00000000000..5e9c60a218a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-present_or_create-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_create  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/data-present_or_create-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/data-present_or_create-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..770dc1ebeef
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/data-present_or_create-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data present_or_create (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/device-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/device-array-pointer.f95
new file mode 100644
index 00000000000..0cc410ffb4a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/device-array-pointer.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc update device (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
+! { dg-final { scan-tree-dump "update" "original" } } 
+! { dg-final { scan-tree-dump "device" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/device-identifier-and-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/device-identifier-and-array-pointer.f95
new file mode 100644
index 00000000000..855e18910e2
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/device-identifier-and-array-pointer.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc update device (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
+! { dg-final { scan-tree-dump "update" "original" } } 
+! { dg-final { scan-tree-dump "device" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/device-identifiers.f95 b/gcc/testsuite/gfortran.dg/gacc/device-identifiers.f95
new file mode 100644
index 00000000000..ef49c559b73
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/device-identifiers.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc update device (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
+! { dg-final { scan-tree-dump "update" "original" } } 
+! { dg-final { scan-tree-dump "device" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/device-integer-literal-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/device-integer-literal-and-identifier_xfail.f95
new file mode 100644
index 00000000000..f424840cf28
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/device-integer-literal-and-identifier_xfail.f95
@@ -0,0 +1,15 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc update device (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/device-integer-literal_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/device-integer-literal_xfail.f95
new file mode 100644
index 00000000000..4ce5669ba78
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/device-integer-literal_xfail.f95
@@ -0,0 +1,15 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc update device (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/device-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/device-pointer.f95
new file mode 100644
index 00000000000..46118f58716
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/device-pointer.f95
@@ -0,0 +1,21 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+	integer, pointer :: y
+	integer, target :: x2 = 4
+	y => x2
+
+!$acc update device (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
+! { dg-final { scan-tree-dump "update" "original" } } 
+! { dg-final { scan-tree-dump "device" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/deviceptr-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/deviceptr-array-pointer.f95
new file mode 100644
index 00000000000..7383aad6be2
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/deviceptr-array-pointer.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data deviceptr (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel deviceptr (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels deviceptr (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "deviceptr" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/deviceptr-identifier-and-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/deviceptr-identifier-and-array-pointer.f95
new file mode 100644
index 00000000000..139a247f5a1
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/deviceptr-identifier-and-array-pointer.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data deviceptr (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel deviceptr (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels deviceptr (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "deviceptr" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/deviceptr-identifiers.f95 b/gcc/testsuite/gfortran.dg/gacc/deviceptr-identifiers.f95
new file mode 100644
index 00000000000..fa0da239e25
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/deviceptr-identifiers.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data deviceptr (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel deviceptr (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels deviceptr (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "deviceptr" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/deviceptr-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/deviceptr-pointer.f95
new file mode 100644
index 00000000000..c2868a98865
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/deviceptr-pointer.f95
@@ -0,0 +1,38 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+	integer, pointer :: y
+	integer, target :: x2 = 4
+	y => x2
+
+!$acc data deviceptr (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel deviceptr (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels deviceptr (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "deviceptr" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/firstprivate-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/firstprivate-array-pointer.f95
new file mode 100644
index 00000000000..5a0bf01a725
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/firstprivate-array-pointer.f95
@@ -0,0 +1,19 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel firstprivate (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "firstprivate" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/firstprivate-identifier-and-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/firstprivate-identifier-and-array-pointer.f95
new file mode 100644
index 00000000000..7d9688528b3
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/firstprivate-identifier-and-array-pointer.f95
@@ -0,0 +1,19 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel firstprivate (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "firstprivate" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/firstprivate-identifiers.f95 b/gcc/testsuite/gfortran.dg/gacc/firstprivate-identifiers.f95
new file mode 100644
index 00000000000..987bf666e2f
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/firstprivate-identifiers.f95
@@ -0,0 +1,19 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel firstprivate (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "firstprivate" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/firstprivate-integer-literal-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/firstprivate-integer-literal-and-identifier_xfail.f95
new file mode 100644
index 00000000000..7124fe29074
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/firstprivate-integer-literal-and-identifier_xfail.f95
@@ -0,0 +1,15 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel firstprivate (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/firstprivate-integer-literal_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/firstprivate-integer-literal_xfail.f95
new file mode 100644
index 00000000000..aa79e3f9fff
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/firstprivate-integer-literal_xfail.f95
@@ -0,0 +1,15 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel firstprivate (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/firstprivate-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/firstprivate-pointer.f95
new file mode 100644
index 00000000000..4b86bb2ec77
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/firstprivate-pointer.f95
@@ -0,0 +1,22 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+	integer, pointer :: y
+	integer, target :: x2 = 4
+	y => x2
+
+!$acc parallel firstprivate (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "firstprivate" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/gacc.exp b/gcc/testsuite/gfortran.dg/gacc/gacc.exp
new file mode 100644
index 00000000000..dc4fade225e
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/gacc.exp
@@ -0,0 +1,36 @@
+# Copyright (C) 2005-2013 Free Software Foundation, Inc.
+#
+# This file is part of GCC.
+#
+# GCC 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 3, or (at your option)
+# any later version.
+#
+# GCC 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 GCC; see the file COPYING3.  If not see
+# <http://www.gnu.org/licenses/>.
+
+# GCC testsuite that uses the `dg.exp' driver.
+
+# Load support procs.
+load_lib gfortran-dg.exp
+
+if ![check_effective_target_fopenmp] {
+  return
+}
+
+# Initialize `dg'.
+dg-init
+
+# Main loop.
+gfortran-dg-runtest [lsort \
+       [find $srcdir/$subdir *.\[fF\]{,90,95,03,08} ] ] " -fopenacc"
+
+# All done.
+dg-finish
diff --git a/gcc/testsuite/gfortran.dg/gacc/gang-double.f95 b/gcc/testsuite/gfortran.dg/gacc/gang-double.f95
new file mode 100644
index 00000000000..0dd2cf70594
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/gang-double.f95
@@ -0,0 +1,44 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop gang (1.5) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop gang (1.5) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel   
+!$acc loop gang (1.5) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop gang (1.5) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "gang" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/gang-empty.f95 b/gcc/testsuite/gfortran.dg/gacc/gang-empty.f95
new file mode 100644
index 00000000000..f43a8379e7f
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/gang-empty.f95
@@ -0,0 +1,44 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop gang  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop gang  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel   
+!$acc loop gang  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop gang  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "gang" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/gang-identifier.f95 b/gcc/testsuite/gfortran.dg/gacc/gang-identifier.f95
new file mode 100644
index 00000000000..96e21125ced
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/gang-identifier.f95
@@ -0,0 +1,44 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop gang (x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop gang (x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel   
+!$acc loop gang (x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop gang (x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "gang" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/gang-integer-literal.f95 b/gcc/testsuite/gfortran.dg/gacc/gang-integer-literal.f95
new file mode 100644
index 00000000000..9278127b7cc
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/gang-integer-literal.f95
@@ -0,0 +1,44 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop gang (10) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop gang (10) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel   
+!$acc loop gang (10) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop gang (10) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "gang" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/gang-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/gang-pointer.f95
new file mode 100644
index 00000000000..62dd7794b7b
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/gang-pointer.f95
@@ -0,0 +1,47 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+	integer, pointer :: y
+	integer, target :: x2 = 4
+	y => x2
+
+!$acc kernels   
+!$acc loop gang (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop gang (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel   
+!$acc loop gang (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop gang (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "gang" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/host-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/host-array-pointer.f95
new file mode 100644
index 00000000000..8f370d56bb2
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/host-array-pointer.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc update host (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
+! { dg-final { scan-tree-dump "update" "original" } } 
+! { dg-final { scan-tree-dump "host" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/host-identifier-and-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/host-identifier-and-array-pointer.f95
new file mode 100644
index 00000000000..6c25d024c2d
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/host-identifier-and-array-pointer.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc update host (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
+! { dg-final { scan-tree-dump "update" "original" } } 
+! { dg-final { scan-tree-dump "host" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/host-identifiers.f95 b/gcc/testsuite/gfortran.dg/gacc/host-identifiers.f95
new file mode 100644
index 00000000000..3dc0610698b
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/host-identifiers.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc update host (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
+! { dg-final { scan-tree-dump "update" "original" } } 
+! { dg-final { scan-tree-dump "host" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/host-integer-literal-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/host-integer-literal-and-identifier_xfail.f95
new file mode 100644
index 00000000000..e661bfa861d
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/host-integer-literal-and-identifier_xfail.f95
@@ -0,0 +1,15 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc update host (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/host-integer-literal_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/host-integer-literal_xfail.f95
new file mode 100644
index 00000000000..20d7259771c
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/host-integer-literal_xfail.f95
@@ -0,0 +1,15 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc update host (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/host-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/host-pointer.f95
new file mode 100644
index 00000000000..df16fa9d8a4
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/host-pointer.f95
@@ -0,0 +1,21 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+	integer, pointer :: y
+	integer, target :: x2 = 4
+	y => x2
+
+!$acc update host (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
+! { dg-final { scan-tree-dump "update" "original" } } 
+! { dg-final { scan-tree-dump "host" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/host_data-use_device-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/host_data-use_device-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..53c1b1bca22
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/host_data-use_device-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc host_data use_device (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end host_data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/host_data-use_device-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/host_data-use_device-empty-list_xfail.f95
new file mode 100644
index 00000000000..eb46417772e
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/host_data-use_device-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc host_data use_device () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end host_data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/host_data-use_device-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/host_data-use_device-empty_xfail.f95
new file mode 100644
index 00000000000..e06f68d7ddb
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/host_data-use_device-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc host_data use_device  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end host_data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/host_data-use_device-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/host_data-use_device-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..a6f127ffcd8
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/host_data-use_device-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc host_data use_device (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end host_data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/host_data-use_device-integer-literal-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/host_data-use_device-integer-literal-and-identifier_xfail.f95
new file mode 100644
index 00000000000..4b8ee012c94
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/host_data-use_device-integer-literal-and-identifier_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc host_data use_device (10, x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end host_data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/host_data-use_device-integer-literal_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/host_data-use_device-integer-literal_xfail.f95
new file mode 100644
index 00000000000..35cbe5bbc76
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/host_data-use_device-integer-literal_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc host_data use_device (10) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end host_data
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/if-integer-literal_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/if-integer-literal_xfail.f95
new file mode 100644
index 00000000000..f14f9806462
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/if-integer-literal_xfail.f95
@@ -0,0 +1,36 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc update if (1) ! { dg-error "requires a scalar LOGICAL expression" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc data if (1) ! { dg-error "requires a scalar LOGICAL expression" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel if (1) ! { dg-error "requires a scalar LOGICAL expression" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels if (1) ! { dg-error "requires a scalar LOGICAL expression" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/independent-empty.f95 b/gcc/testsuite/gfortran.dg/gacc/independent-empty.f95
new file mode 100644
index 00000000000..fc0ce190b13
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/independent-empty.f95
@@ -0,0 +1,28 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop independent  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop independent  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "independent" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-async-empty-sie_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-async-empty-sie_xfail.f95
new file mode 100644
index 00000000000..e6dfb832a0a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-async-empty-sie_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels async () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-async-identifier-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-async-identifier-without-bracket_xfail.f95
new file mode 100644
index 00000000000..a9e97012f4d
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-async-identifier-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels async (x1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-async-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-async-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..88c12d5ec86
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-async-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels async (10 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-copy-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-copy-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..7e824e1f443
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-copy-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels copy (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-copy-array-without-semocolon-and-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-copy-array-without-semocolon-and-limits_xfail.f95
new file mode 100644
index 00000000000..d1039c74352
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-copy-array-without-semocolon-and-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels copy (a1()) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-copy-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-copy-empty-list_xfail.f95
new file mode 100644
index 00000000000..adefff6a029
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-copy-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels copy () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-copy-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-copy-empty_xfail.f95
new file mode 100644
index 00000000000..a4a49208f48
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-copy-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels copy  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-copy-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-copy-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..04163b4d9b7
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-copy-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels copy (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-copyin-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-copyin-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..9cf152fa8ca
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-copyin-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels copyin (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-copyin-array-without-semocolon-and-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-copyin-array-without-semocolon-and-limits_xfail.f95
new file mode 100644
index 00000000000..ba7be9f6cfc
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-copyin-array-without-semocolon-and-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels copyin (a1()) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-copyin-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-copyin-empty-list_xfail.f95
new file mode 100644
index 00000000000..4cc95912ebd
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-copyin-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels copyin () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-copyin-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-copyin-empty_xfail.f95
new file mode 100644
index 00000000000..1286f9233d2
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-copyin-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels copyin  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-copyin-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-copyin-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..5086585a077
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-copyin-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels copyin (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-copyout-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-copyout-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..b3ddbe09d8b
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-copyout-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels copyout (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-copyout-array-without-semocolon-and-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-copyout-array-without-semocolon-and-limits_xfail.f95
new file mode 100644
index 00000000000..7bd8e585abe
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-copyout-array-without-semocolon-and-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels copyout (a1()) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-copyout-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-copyout-empty-list_xfail.f95
new file mode 100644
index 00000000000..4d4ba5bd847
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-copyout-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels copyout () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-copyout-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-copyout-empty_xfail.f95
new file mode 100644
index 00000000000..e8a1058ef7f
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-copyout-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels copyout  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-copyout-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-copyout-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..bcbed3465c9
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-copyout-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels copyout (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-create-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-create-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..c04fcd33575
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-create-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels create (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-create-array-without-semocolon-and-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-create-array-without-semocolon-and-limits_xfail.f95
new file mode 100644
index 00000000000..70390dfd54e
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-create-array-without-semocolon-and-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels create (a1()) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-create-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-create-empty-list_xfail.f95
new file mode 100644
index 00000000000..40863a00ae0
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-create-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels create () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-create-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-create-empty_xfail.f95
new file mode 100644
index 00000000000..5ce33e4a9dd
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-create-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels create  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-create-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-create-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..786a451bd2e
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-create-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels create (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-deviceptr-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-deviceptr-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..b8741373995
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-deviceptr-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels deviceptr (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-deviceptr-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-deviceptr-empty-list_xfail.f95
new file mode 100644
index 00000000000..4e03910c6ad
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-deviceptr-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels deviceptr () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-deviceptr-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-deviceptr-empty_xfail.f95
new file mode 100644
index 00000000000..553537414f7
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-deviceptr-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels deviceptr  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-deviceptr-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-deviceptr-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..49ebf3fc79d
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-deviceptr-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels deviceptr (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-deviceptr-integer-literal-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-deviceptr-integer-literal-and-identifier_xfail.f95
new file mode 100644
index 00000000000..69c0293d1c2
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-deviceptr-integer-literal-and-identifier_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels deviceptr (10, x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-deviceptr-integer-literal_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-deviceptr-integer-literal_xfail.f95
new file mode 100644
index 00000000000..e373c3a3ea8
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-deviceptr-integer-literal_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels deviceptr (10) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-if-array-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-if-array-limits_xfail.f95
new file mode 100644
index 00000000000..1f331ab501c
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-if-array-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels if (a1(2:5)) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-if-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-if-empty_xfail.f95
new file mode 100644
index 00000000000..baa66213ab1
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-if-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels if  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-if-expresion-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-if-expresion-without-bracket_xfail.f95
new file mode 100644
index 00000000000..1e03b87d024
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-if-expresion-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels if (1 == 0 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-if-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-if-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..33c8eb1a8ce
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-if-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels if 1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-if-white-space_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-if-white-space_xfail.f95
new file mode 100644
index 00000000000..35520c59697
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-if-white-space_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels if () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-present-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-present-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..28a19d6e1de
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-present-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels present (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-present-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-present-empty-list_xfail.f95
new file mode 100644
index 00000000000..895981d3052
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-present-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels present () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-present-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-present-empty_xfail.f95
new file mode 100644
index 00000000000..6855ecac1a0
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-present-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels present  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-present-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-present-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..c22eb5ac587
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-present-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels present (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copy-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copy-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..64576654c65
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copy-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels present_or_copy (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copy-array-without-semocolon-and-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copy-array-without-semocolon-and-limits_xfail.f95
new file mode 100644
index 00000000000..7384ad38dd1
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copy-array-without-semocolon-and-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels present_or_copy (a1()) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copy-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copy-empty-list_xfail.f95
new file mode 100644
index 00000000000..438b4493606
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copy-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels present_or_copy () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copy-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copy-empty_xfail.f95
new file mode 100644
index 00000000000..670e8cdff4a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copy-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels present_or_copy  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copy-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copy-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..6507ca34856
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copy-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels present_or_copy (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyin-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyin-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..c01d6395448
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyin-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels present_or_copyin (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyin-array-without-semocolon-and-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyin-array-without-semocolon-and-limits_xfail.f95
new file mode 100644
index 00000000000..b8417e7a795
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyin-array-without-semocolon-and-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels present_or_copyin (a1()) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyin-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyin-empty-list_xfail.f95
new file mode 100644
index 00000000000..3cb2386018e
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyin-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels present_or_copyin () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyin-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyin-empty_xfail.f95
new file mode 100644
index 00000000000..aadb3527e76
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyin-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels present_or_copyin  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyin-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyin-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..28e1a399ad6
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyin-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels present_or_copyin (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyout-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyout-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..58b674afbd2
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyout-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels present_or_copyout (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyout-array-without-semocolon-and-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyout-array-without-semocolon-and-limits_xfail.f95
new file mode 100644
index 00000000000..ae5b81edae3
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyout-array-without-semocolon-and-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels present_or_copyout (a1()) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyout-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyout-empty-list_xfail.f95
new file mode 100644
index 00000000000..7a1999fd5c1
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyout-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels present_or_copyout () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyout-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyout-empty_xfail.f95
new file mode 100644
index 00000000000..c297de42640
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyout-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels present_or_copyout  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyout-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyout-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..29de8e88c40
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_copyout-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels present_or_copyout (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_create-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_create-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..d8b8771b35a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_create-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels present_or_create (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_create-array-without-semocolon-and-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_create-array-without-semocolon-and-limits_xfail.f95
new file mode 100644
index 00000000000..47d1832ef71
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_create-array-without-semocolon-and-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels present_or_create (a1()) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_create-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_create-empty-list_xfail.f95
new file mode 100644
index 00000000000..67bd2940a2f
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_create-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels present_or_create () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_create-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_create-empty_xfail.f95
new file mode 100644
index 00000000000..1e21f97c9b6
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_create-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels present_or_create  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_create-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_create-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..ec46d1d4984
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels-present_or_create-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels present_or_create (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-collapse-empty-sie_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-collapse-empty-sie_xfail.f95
new file mode 100644
index 00000000000..8fc11d83f98
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-collapse-empty-sie_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels loop collapse () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-collapse-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-collapse-empty_xfail.f95
new file mode 100644
index 00000000000..491f34c6629
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-collapse-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels loop collapse  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-collapse-identifier-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-collapse-identifier-without-bracket_xfail.f95
new file mode 100644
index 00000000000..a5043618643
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-collapse-identifier-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels loop collapse (x1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-collapse-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-collapse-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..53bebba6588
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-collapse-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels loop collapse (10 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-gang-empty-sie_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-gang-empty-sie_xfail.f95
new file mode 100644
index 00000000000..b203de83b1f
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-gang-empty-sie_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels loop gang () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-gang-identifier-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-gang-identifier-without-bracket_xfail.f95
new file mode 100644
index 00000000000..f436008db64
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-gang-identifier-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels loop gang (x1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-gang-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-gang-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..7e63a0bfc83
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-gang-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels loop gang (10 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-independent-brackets_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-independent-brackets_xfail.f95
new file mode 100644
index 00000000000..69e8299d1ad
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-independent-brackets_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels loop independent () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-private-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-private-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..a78b080bf23
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-private-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels loop private (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-private-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-private-empty-list_xfail.f95
new file mode 100644
index 00000000000..d7e5f499da6
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-private-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels loop private () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-private-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-private-empty_xfail.f95
new file mode 100644
index 00000000000..6f34eb30539
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-private-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels loop private  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-private-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-private-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..035c2d9fc19
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-private-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels loop private (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-add-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-add-empty-list_xfail.f95
new file mode 100644
index 00000000000..f3299498c22
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-add-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels loop reduction (+:) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-add-integer-literals_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-add-integer-literals_xfail.f95
new file mode 100644
index 00000000000..c2a56c58fd7
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-add-integer-literals_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels loop reduction (+:1,2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-binary-and-integer-literal-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-binary-and-integer-literal-and-identifier_xfail.f95
new file mode 100644
index 00000000000..1a0c2029656
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-binary-and-integer-literal-and-identifier_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels loop reduction (.and.:1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-list-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-list-without-comma_xfail.f95
new file mode 100644
index 00000000000..1727e27b1fe
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-list-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels loop reduction (+:x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-min-array-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-min-array-and-identifier_xfail.f95
new file mode 100644
index 00000000000..d229359da5c
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-min-array-and-identifier_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels loop reduction (min:a1(1),x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-without-left-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-without-left-bracket_xfail.f95
new file mode 100644
index 00000000000..7925bb3d56f
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-without-left-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels loop reduction *:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-without-operation_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-without-operation_xfail.f95
new file mode 100644
index 00000000000..ad25572ef2c
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-without-operation_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels loop reduction (:x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-without-rigth-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-without-rigth-bracket_xfail.f95
new file mode 100644
index 00000000000..d11cbcd640b
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-without-rigth-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels loop reduction (max:x1,x2 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-without-semocolon_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-without-semocolon_xfail.f95
new file mode 100644
index 00000000000..0b6f9e8b4e9
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-reduction-without-semocolon_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels loop reduction (iand x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-seq-brackets_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-seq-brackets_xfail.f95
new file mode 100644
index 00000000000..5ece3549794
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-seq-brackets_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels loop seq () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-vector-empty-sie_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-vector-empty-sie_xfail.f95
new file mode 100644
index 00000000000..f5484d712ec
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-vector-empty-sie_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels loop vector () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-vector-identifier-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-vector-identifier-without-bracket_xfail.f95
new file mode 100644
index 00000000000..9292954acf7
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-vector-identifier-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels loop vector (x1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-vector-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-vector-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..985b8c3144f
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-vector-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels loop vector (10 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-worker-empty-sie_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-worker-empty-sie_xfail.f95
new file mode 100644
index 00000000000..ff4f74290a5
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-worker-empty-sie_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels loop worker () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-worker-identifier-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-worker-identifier-without-bracket_xfail.f95
new file mode 100644
index 00000000000..0d7a6320afe
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-worker-identifier-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels loop worker (x1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/kernels_loop-worker-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-worker-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..ca843ba7f6b
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/kernels_loop-worker-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels loop worker (10 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-collapse-empty-sie_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-collapse-empty-sie_xfail.f95
new file mode 100644
index 00000000000..965345dbfa8
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-collapse-empty-sie_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop collapse () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-collapse-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-collapse-empty_xfail.f95
new file mode 100644
index 00000000000..b22628e6dd3
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-collapse-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop collapse  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-collapse-identifier-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-collapse-identifier-without-bracket_xfail.f95
new file mode 100644
index 00000000000..0cf7ab34b4a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-collapse-identifier-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop collapse (x1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-collapse-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-collapse-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..70775872a39
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-collapse-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop collapse (10 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-gang-empty-sie_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-gang-empty-sie_xfail.f95
new file mode 100644
index 00000000000..2610fd6c373
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-gang-empty-sie_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop gang () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-gang-identifier-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-gang-identifier-without-bracket_xfail.f95
new file mode 100644
index 00000000000..1b727af4a8a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-gang-identifier-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop gang (x1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-gang-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-gang-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..05489fa4dfc
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-gang-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop gang (10 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-independent-brackets_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-independent-brackets_xfail.f95
new file mode 100644
index 00000000000..86792fe80e7
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-independent-brackets_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop independent () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-private-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-private-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..a8a5b08d1a2
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-private-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop private (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-private-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-private-empty-list_xfail.f95
new file mode 100644
index 00000000000..3c26dbb4c44
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-private-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop private () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-private-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-private-empty_xfail.f95
new file mode 100644
index 00000000000..34453624889
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-private-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop private  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-private-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-private-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..48cea64a3e5
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-private-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels   
+!$acc loop private (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-add-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-add-empty-list_xfail.f95
new file mode 100644
index 00000000000..eb4d307fff3
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-add-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop reduction (+:) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-add-integer-literals_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-add-integer-literals_xfail.f95
new file mode 100644
index 00000000000..9ecfc53ac90
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-add-integer-literals_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop reduction (+:1,2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-binary-and-integer-literal-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-binary-and-integer-literal-and-identifier_xfail.f95
new file mode 100644
index 00000000000..5a863d28e01
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-binary-and-integer-literal-and-identifier_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels   
+!$acc loop reduction (.and.:1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-list-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-list-without-comma_xfail.f95
new file mode 100644
index 00000000000..736c2250b4f
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-list-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels   
+!$acc loop reduction (+:x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-min-array-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-min-array-and-identifier_xfail.f95
new file mode 100644
index 00000000000..4aa83987128
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-min-array-and-identifier_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels   
+!$acc loop reduction (min:a1(1),x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-without-left-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-without-left-bracket_xfail.f95
new file mode 100644
index 00000000000..66b398aab4e
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-without-left-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels   
+!$acc loop reduction *:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-without-operation_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-without-operation_xfail.f95
new file mode 100644
index 00000000000..a5267d7b896
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-without-operation_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop reduction (:x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-without-rigth-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-without-rigth-bracket_xfail.f95
new file mode 100644
index 00000000000..3cc55cbbfe9
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-without-rigth-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels   
+!$acc loop reduction (max:x1,x2 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-without-semocolon_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-without-semocolon_xfail.f95
new file mode 100644
index 00000000000..9662ed45cf7
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-reduction-without-semocolon_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop reduction (iand x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-seq-brackets_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-seq-brackets_xfail.f95
new file mode 100644
index 00000000000..405ffedce95
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-seq-brackets_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop seq () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-vector-empty-sie_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-vector-empty-sie_xfail.f95
new file mode 100644
index 00000000000..e07fd055e32
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-vector-empty-sie_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop vector () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-vector-identifier-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-vector-identifier-without-bracket_xfail.f95
new file mode 100644
index 00000000000..c015bd2dbd5
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-vector-identifier-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop vector (x1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-vector-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-vector-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..9ffde0b9116
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-vector-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop vector (10 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-worker-empty-sie_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-worker-empty-sie_xfail.f95
new file mode 100644
index 00000000000..526de60d284
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-worker-empty-sie_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop worker () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-worker-identifier-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-worker-identifier-without-bracket_xfail.f95
new file mode 100644
index 00000000000..26c60548bc2
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-worker-identifier-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop worker (x1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-worker-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-worker-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..5662d209404
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_kernels-worker-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop worker (10 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-collapse-empty-sie_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-collapse-empty-sie_xfail.f95
new file mode 100644
index 00000000000..ed28345339b
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-collapse-empty-sie_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel   
+!$acc loop collapse () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-collapse-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-collapse-empty_xfail.f95
new file mode 100644
index 00000000000..93ce22de572
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-collapse-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel   
+!$acc loop collapse  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-collapse-identifier-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-collapse-identifier-without-bracket_xfail.f95
new file mode 100644
index 00000000000..14b30176080
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-collapse-identifier-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel   
+!$acc loop collapse (x1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-collapse-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-collapse-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..8bc77ec9ad2
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-collapse-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel   
+!$acc loop collapse (10 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-gang-empty-sie_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-gang-empty-sie_xfail.f95
new file mode 100644
index 00000000000..4e2d26ce1b4
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-gang-empty-sie_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel   
+!$acc loop gang () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-gang-identifier-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-gang-identifier-without-bracket_xfail.f95
new file mode 100644
index 00000000000..4bce838d9e7
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-gang-identifier-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel   
+!$acc loop gang (x1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-gang-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-gang-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..ffb749b3ed5
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-gang-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel   
+!$acc loop gang (10 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-independent-brackets_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-independent-brackets_xfail.f95
new file mode 100644
index 00000000000..79813f61b43
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-independent-brackets_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel   
+!$acc loop independent () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-private-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-private-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..735262ffaa4
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-private-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel   
+!$acc loop private (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-private-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-private-empty-list_xfail.f95
new file mode 100644
index 00000000000..7de2b8afcac
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-private-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel   
+!$acc loop private () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-private-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-private-empty_xfail.f95
new file mode 100644
index 00000000000..16f61f944e0
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-private-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel   
+!$acc loop private  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-private-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-private-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..dc024343373
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-private-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel   
+!$acc loop private (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-add-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-add-empty-list_xfail.f95
new file mode 100644
index 00000000000..63b47827835
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-add-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel   
+!$acc loop reduction (+:) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-add-integer-literals_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-add-integer-literals_xfail.f95
new file mode 100644
index 00000000000..6b2b2757859
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-add-integer-literals_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel   
+!$acc loop reduction (+:1,2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-binary-and-integer-literal-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-binary-and-integer-literal-and-identifier_xfail.f95
new file mode 100644
index 00000000000..d16dc1dc549
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-binary-and-integer-literal-and-identifier_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel   
+!$acc loop reduction (.and.:1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-list-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-list-without-comma_xfail.f95
new file mode 100644
index 00000000000..07051e3e82a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-list-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel   
+!$acc loop reduction (+:x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-min-array-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-min-array-and-identifier_xfail.f95
new file mode 100644
index 00000000000..386946edfd3
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-min-array-and-identifier_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel   
+!$acc loop reduction (min:a1(1),x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-without-left-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-without-left-bracket_xfail.f95
new file mode 100644
index 00000000000..8af5dbd31ed
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-without-left-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel   
+!$acc loop reduction *:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-without-operation_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-without-operation_xfail.f95
new file mode 100644
index 00000000000..34b59af4a11
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-without-operation_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel   
+!$acc loop reduction (:x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-without-rigth-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-without-rigth-bracket_xfail.f95
new file mode 100644
index 00000000000..c2524030f4d
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-without-rigth-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel   
+!$acc loop reduction (max:x1,x2 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-without-semocolon_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-without-semocolon_xfail.f95
new file mode 100644
index 00000000000..137b95ca267
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-reduction-without-semocolon_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel   
+!$acc loop reduction (iand x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-seq-brackets_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-seq-brackets_xfail.f95
new file mode 100644
index 00000000000..c3923686e8d
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-seq-brackets_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel   
+!$acc loop seq () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-vector-empty-sie_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-vector-empty-sie_xfail.f95
new file mode 100644
index 00000000000..e487670294f
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-vector-empty-sie_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel   
+!$acc loop vector () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-vector-identifier-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-vector-identifier-without-bracket_xfail.f95
new file mode 100644
index 00000000000..619584b3100
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-vector-identifier-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel   
+!$acc loop vector (x1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-vector-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-vector-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..00c93cdde9b
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-vector-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel   
+!$acc loop vector (10 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-worker-empty-sie_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-worker-empty-sie_xfail.f95
new file mode 100644
index 00000000000..c2f748a22b0
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-worker-empty-sie_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel   
+!$acc loop worker () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-worker-identifier-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-worker-identifier-without-bracket_xfail.f95
new file mode 100644
index 00000000000..581351d5c51
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-worker-identifier-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel   
+!$acc loop worker (x1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-worker-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-worker-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..ee655f363e8
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/loop_in_parallel-worker-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel   
+!$acc loop worker (10 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/num_gangs-double_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/num_gangs-double_xfail.f95
new file mode 100644
index 00000000000..0f5e416a7d3
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/num_gangs-double_xfail.f95
@@ -0,0 +1,16 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel num_gangs (1.5) ! { dg-error "requires a scalar INTEGER expression" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/num_gangs-identifier.f95 b/gcc/testsuite/gfortran.dg/gacc/num_gangs-identifier.f95
new file mode 100644
index 00000000000..441fcfc167d
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/num_gangs-identifier.f95
@@ -0,0 +1,19 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel num_gangs (x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "num_gangs" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/num_gangs-integer-literal.f95 b/gcc/testsuite/gfortran.dg/gacc/num_gangs-integer-literal.f95
new file mode 100644
index 00000000000..ce07ed60c53
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/num_gangs-integer-literal.f95
@@ -0,0 +1,19 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel num_gangs (10) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "num_gangs" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/num_gangs-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/num_gangs-pointer.f95
new file mode 100644
index 00000000000..0e658a5cda7
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/num_gangs-pointer.f95
@@ -0,0 +1,22 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+	integer, pointer :: y
+	integer, target :: x2 = 4
+	y => x2
+
+!$acc parallel num_gangs (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "num_gangs" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/num_workers-double_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/num_workers-double_xfail.f95
new file mode 100644
index 00000000000..8c2f5a32db1
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/num_workers-double_xfail.f95
@@ -0,0 +1,16 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel num_workers (1.5) ! { dg-error "requires a scalar INTEGER expression" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/num_workers-identifier.f95 b/gcc/testsuite/gfortran.dg/gacc/num_workers-identifier.f95
new file mode 100644
index 00000000000..1606ecfee2c
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/num_workers-identifier.f95
@@ -0,0 +1,19 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel num_workers (x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "num_workers" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/num_workers-integer-literal.f95 b/gcc/testsuite/gfortran.dg/gacc/num_workers-integer-literal.f95
new file mode 100644
index 00000000000..e869f13680a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/num_workers-integer-literal.f95
@@ -0,0 +1,19 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel num_workers (10) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "num_workers" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/num_workers-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/num_workers-pointer.f95
new file mode 100644
index 00000000000..9e8db099690
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/num_workers-pointer.f95
@@ -0,0 +1,22 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+	integer, pointer :: y
+	integer, target :: x2 = 4
+	y => x2
+
+!$acc parallel num_workers (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "num_workers" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-async-empty-sie_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-async-empty-sie_xfail.f95
new file mode 100644
index 00000000000..8b34c31eee8
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-async-empty-sie_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel async () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-async-identifier-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-async-identifier-without-bracket_xfail.f95
new file mode 100644
index 00000000000..3ca7417a176
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-async-identifier-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel async (x1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-async-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-async-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..3f711b9055e
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-async-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel async (10 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-copy-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-copy-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..7b28ddba6c0
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-copy-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel copy (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-copy-array-without-semocolon-and-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-copy-array-without-semocolon-and-limits_xfail.f95
new file mode 100644
index 00000000000..e338ced3084
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-copy-array-without-semocolon-and-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel copy (a1()) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-copy-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-copy-empty-list_xfail.f95
new file mode 100644
index 00000000000..575a4120579
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-copy-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel copy () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-copy-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-copy-empty_xfail.f95
new file mode 100644
index 00000000000..c839c04ff8c
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-copy-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel copy  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-copy-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-copy-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..12a1b9da4b9
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-copy-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel copy (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-copyin-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-copyin-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..ed005490e06
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-copyin-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel copyin (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-copyin-array-without-semocolon-and-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-copyin-array-without-semocolon-and-limits_xfail.f95
new file mode 100644
index 00000000000..9fa43c49020
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-copyin-array-without-semocolon-and-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel copyin (a1()) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-copyin-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-copyin-empty-list_xfail.f95
new file mode 100644
index 00000000000..a8bf78b7914
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-copyin-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel copyin () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-copyin-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-copyin-empty_xfail.f95
new file mode 100644
index 00000000000..4dab458e173
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-copyin-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel copyin  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-copyin-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-copyin-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..328443ec452
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-copyin-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel copyin (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-copyout-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-copyout-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..141b09d9e2a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-copyout-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel copyout (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-copyout-array-without-semocolon-and-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-copyout-array-without-semocolon-and-limits_xfail.f95
new file mode 100644
index 00000000000..3fc9f834631
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-copyout-array-without-semocolon-and-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel copyout (a1()) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-copyout-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-copyout-empty-list_xfail.f95
new file mode 100644
index 00000000000..23cd9801581
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-copyout-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel copyout () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-copyout-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-copyout-empty_xfail.f95
new file mode 100644
index 00000000000..ed93fea2acf
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-copyout-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel copyout  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-copyout-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-copyout-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..82ede93d6cf
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-copyout-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel copyout (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-create-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-create-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..40015e334bd
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-create-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel create (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-create-array-without-semocolon-and-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-create-array-without-semocolon-and-limits_xfail.f95
new file mode 100644
index 00000000000..1c6c99350ea
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-create-array-without-semocolon-and-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel create (a1()) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-create-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-create-empty-list_xfail.f95
new file mode 100644
index 00000000000..1bb7a5285a4
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-create-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel create () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-create-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-create-empty_xfail.f95
new file mode 100644
index 00000000000..81fdd140b15
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-create-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel create  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-create-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-create-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..12a82bec946
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-create-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel create (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-deviceptr-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-deviceptr-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..a6ff1d40c31
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-deviceptr-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel deviceptr (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-deviceptr-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-deviceptr-empty-list_xfail.f95
new file mode 100644
index 00000000000..e8ae0c5f27d
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-deviceptr-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel deviceptr () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-deviceptr-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-deviceptr-empty_xfail.f95
new file mode 100644
index 00000000000..29baca42ef3
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-deviceptr-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel deviceptr  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-deviceptr-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-deviceptr-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..3a350f7a339
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-deviceptr-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel deviceptr (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-deviceptr-integer-literal-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-deviceptr-integer-literal-and-identifier_xfail.f95
new file mode 100644
index 00000000000..3c3224b4b71
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-deviceptr-integer-literal-and-identifier_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel deviceptr (10, x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-deviceptr-integer-literal_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-deviceptr-integer-literal_xfail.f95
new file mode 100644
index 00000000000..7df38ed9cc3
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-deviceptr-integer-literal_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel deviceptr (10) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-firstprivate-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-firstprivate-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..7970478b3c0
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-firstprivate-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel firstprivate (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-firstprivate-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-firstprivate-empty-list_xfail.f95
new file mode 100644
index 00000000000..f999cd0a094
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-firstprivate-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel firstprivate () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-firstprivate-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-firstprivate-empty_xfail.f95
new file mode 100644
index 00000000000..4f40425bef9
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-firstprivate-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel firstprivate  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-firstprivate-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-firstprivate-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..cc77886510e
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-firstprivate-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel firstprivate (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-if-array-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-if-array-limits_xfail.f95
new file mode 100644
index 00000000000..12fca91b16f
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-if-array-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel if (a1(2:5)) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-if-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-if-empty_xfail.f95
new file mode 100644
index 00000000000..24b1c8b6cd3
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-if-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel if  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-if-expresion-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-if-expresion-without-bracket_xfail.f95
new file mode 100644
index 00000000000..53e8c1e30e5
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-if-expresion-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel if (1 == 0 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-if-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-if-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..874228e626b
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-if-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel if 1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-if-white-space_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-if-white-space_xfail.f95
new file mode 100644
index 00000000000..ad926c8caf9
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-if-white-space_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel if () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-num_gangs-empty-sie_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-num_gangs-empty-sie_xfail.f95
new file mode 100644
index 00000000000..c762e387305
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-num_gangs-empty-sie_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel num_gangs () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-num_gangs-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-num_gangs-empty_xfail.f95
new file mode 100644
index 00000000000..8c355a7b714
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-num_gangs-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel num_gangs  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-num_gangs-identifier-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-num_gangs-identifier-without-bracket_xfail.f95
new file mode 100644
index 00000000000..27de6adb49a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-num_gangs-identifier-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel num_gangs (x1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-num_gangs-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-num_gangs-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..8efa6e01c0d
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-num_gangs-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel num_gangs (10 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-num_workers-empty-sie_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-num_workers-empty-sie_xfail.f95
new file mode 100644
index 00000000000..946f3f14551
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-num_workers-empty-sie_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel num_workers () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-num_workers-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-num_workers-empty_xfail.f95
new file mode 100644
index 00000000000..fcd29cff4b4
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-num_workers-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel num_workers  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-num_workers-identifier-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-num_workers-identifier-without-bracket_xfail.f95
new file mode 100644
index 00000000000..6efda348a12
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-num_workers-identifier-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel num_workers (x1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-num_workers-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-num_workers-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..5b0cda52805
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-num_workers-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel num_workers (10 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-present-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-present-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..5770f8ea5ca
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-present-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel present (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-present-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-present-empty-list_xfail.f95
new file mode 100644
index 00000000000..6036411426a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-present-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel present () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-present-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-present-empty_xfail.f95
new file mode 100644
index 00000000000..dada5c644ee
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-present-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel present  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-present-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-present-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..8f385a45094
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-present-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel present (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copy-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copy-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..dbbe35cd9b9
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copy-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel present_or_copy (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copy-array-without-semocolon-and-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copy-array-without-semocolon-and-limits_xfail.f95
new file mode 100644
index 00000000000..07efff43fd1
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copy-array-without-semocolon-and-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel present_or_copy (a1()) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copy-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copy-empty-list_xfail.f95
new file mode 100644
index 00000000000..a6662760c93
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copy-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel present_or_copy () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copy-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copy-empty_xfail.f95
new file mode 100644
index 00000000000..d0005219fa8
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copy-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel present_or_copy  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copy-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copy-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..0622b99f611
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copy-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel present_or_copy (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyin-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyin-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..df49b716e33
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyin-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel present_or_copyin (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyin-array-without-semocolon-and-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyin-array-without-semocolon-and-limits_xfail.f95
new file mode 100644
index 00000000000..73c4abaca98
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyin-array-without-semocolon-and-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel present_or_copyin (a1()) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyin-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyin-empty-list_xfail.f95
new file mode 100644
index 00000000000..02c669f3107
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyin-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel present_or_copyin () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyin-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyin-empty_xfail.f95
new file mode 100644
index 00000000000..50a889179fc
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyin-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel present_or_copyin  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyin-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyin-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..e5f36e349d6
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyin-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel present_or_copyin (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyout-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyout-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..f1018c25429
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyout-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel present_or_copyout (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyout-array-without-semocolon-and-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyout-array-without-semocolon-and-limits_xfail.f95
new file mode 100644
index 00000000000..e02c52cacb1
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyout-array-without-semocolon-and-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel present_or_copyout (a1()) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyout-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyout-empty-list_xfail.f95
new file mode 100644
index 00000000000..a5d58f64743
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyout-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel present_or_copyout () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyout-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyout-empty_xfail.f95
new file mode 100644
index 00000000000..fdd551b54bc
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyout-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel present_or_copyout  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyout-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyout-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..a285bd6b32b
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_copyout-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel present_or_copyout (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_create-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_create-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..e15e89228a0
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_create-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel present_or_create (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_create-array-without-semocolon-and-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_create-array-without-semocolon-and-limits_xfail.f95
new file mode 100644
index 00000000000..20f2090a00c
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_create-array-without-semocolon-and-limits_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel present_or_create (a1()) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_create-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_create-empty-list_xfail.f95
new file mode 100644
index 00000000000..a729fa89718
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_create-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel present_or_create () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_create-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_create-empty_xfail.f95
new file mode 100644
index 00000000000..5354eb523cf
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_create-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel present_or_create  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_create-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_create-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..c40d301c117
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-present_or_create-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel present_or_create (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-private-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-private-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..5a8d4790173
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-private-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel private (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-private-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-private-empty-list_xfail.f95
new file mode 100644
index 00000000000..bc2a1eb6bf1
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-private-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel private () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-private-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-private-empty_xfail.f95
new file mode 100644
index 00000000000..8f01e3b9389
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-private-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel private  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-private-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-private-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..18aba3e11e5
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-private-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel private (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-add-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-add-empty-list_xfail.f95
new file mode 100644
index 00000000000..d44bbaf8e5a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-add-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel reduction (+:) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-add-integer-literals_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-add-integer-literals_xfail.f95
new file mode 100644
index 00000000000..9c7c29d359e
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-add-integer-literals_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel reduction (+:1,2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-binary-and-integer-literal-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-binary-and-integer-literal-and-identifier_xfail.f95
new file mode 100644
index 00000000000..6d557c20cd5
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-binary-and-integer-literal-and-identifier_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel reduction (.and.:1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-list-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-list-without-comma_xfail.f95
new file mode 100644
index 00000000000..ba36d548055
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-list-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel reduction (+:x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-min-array-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-min-array-and-identifier_xfail.f95
new file mode 100644
index 00000000000..3b76894bafb
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-min-array-and-identifier_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel reduction (min:a1(1),x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-without-left-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-without-left-bracket_xfail.f95
new file mode 100644
index 00000000000..fe6aef76e61
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-without-left-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel reduction *:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-without-operation_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-without-operation_xfail.f95
new file mode 100644
index 00000000000..d60a376dce2
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-without-operation_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel reduction (:x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-without-rigth-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-without-rigth-bracket_xfail.f95
new file mode 100644
index 00000000000..e4fc2d020ee
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-without-rigth-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel reduction (max:x1,x2 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-without-semocolon_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-without-semocolon_xfail.f95
new file mode 100644
index 00000000000..c2b19af5372
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-reduction-without-semocolon_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel reduction (iand x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-vector_length-empty-sie_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-vector_length-empty-sie_xfail.f95
new file mode 100644
index 00000000000..a115899d88c
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-vector_length-empty-sie_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel vector_length () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-vector_length-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-vector_length-empty_xfail.f95
new file mode 100644
index 00000000000..75b905d76c9
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-vector_length-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel vector_length  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-vector_length-identifier-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-vector_length-identifier-without-bracket_xfail.f95
new file mode 100644
index 00000000000..27263398f7d
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-vector_length-identifier-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel vector_length (x1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel-vector_length-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel-vector_length-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..026a8e367e9
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel-vector_length-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel vector_length (10 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-collapse-empty-sie_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-collapse-empty-sie_xfail.f95
new file mode 100644
index 00000000000..0bc9961a416
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-collapse-empty-sie_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel loop collapse () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-collapse-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-collapse-empty_xfail.f95
new file mode 100644
index 00000000000..4fbe95e6182
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-collapse-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel loop collapse  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-collapse-identifier-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-collapse-identifier-without-bracket_xfail.f95
new file mode 100644
index 00000000000..9dbb7415318
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-collapse-identifier-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel loop collapse (x1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-collapse-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-collapse-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..23d3cee73c7
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-collapse-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel loop collapse (10 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-gang-empty-sie_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-gang-empty-sie_xfail.f95
new file mode 100644
index 00000000000..ca6fb00d4f4
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-gang-empty-sie_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel loop gang () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-gang-identifier-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-gang-identifier-without-bracket_xfail.f95
new file mode 100644
index 00000000000..f6db4080935
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-gang-identifier-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel loop gang (x1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-gang-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-gang-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..bdad327fcec
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-gang-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel loop gang (10 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-private-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-private-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..293dd9ae0e9
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-private-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel loop private (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-private-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-private-empty-list_xfail.f95
new file mode 100644
index 00000000000..ba24dba98a0
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-private-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel loop private () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-private-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-private-empty_xfail.f95
new file mode 100644
index 00000000000..ed2ad50cc10
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-private-empty_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel loop private  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-private-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-private-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..1ed5a76a0f3
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-private-identifiers-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel loop private (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-add-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-add-empty-list_xfail.f95
new file mode 100644
index 00000000000..80e2a2ed19f
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-add-empty-list_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel loop reduction (+:) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-add-integer-literals_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-add-integer-literals_xfail.f95
new file mode 100644
index 00000000000..8e00c6a440b
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-add-integer-literals_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel loop reduction (+:1,2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-binary-and-integer-literal-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-binary-and-integer-literal-and-identifier_xfail.f95
new file mode 100644
index 00000000000..ae1999679fb
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-binary-and-integer-literal-and-identifier_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel loop reduction (.and.:1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-list-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-list-without-comma_xfail.f95
new file mode 100644
index 00000000000..5a71d809db0
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-list-without-comma_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel loop reduction (+:x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-min-array-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-min-array-and-identifier_xfail.f95
new file mode 100644
index 00000000000..14248d2f39b
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-min-array-and-identifier_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel loop reduction (min:a1(1),x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-without-left-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-without-left-bracket_xfail.f95
new file mode 100644
index 00000000000..8f67a41fac4
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-without-left-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel loop reduction *:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-without-operation_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-without-operation_xfail.f95
new file mode 100644
index 00000000000..6424c3218e1
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-without-operation_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel loop reduction (:x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-without-rigth-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-without-rigth-bracket_xfail.f95
new file mode 100644
index 00000000000..74aeb05eee2
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-without-rigth-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc parallel loop reduction (max:x1,x2 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-without-semocolon_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-without-semocolon_xfail.f95
new file mode 100644
index 00000000000..9240fb4653f
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-reduction-without-semocolon_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel loop reduction (iand x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-seq-brackets_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-seq-brackets_xfail.f95
new file mode 100644
index 00000000000..375bec65afa
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-seq-brackets_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel loop seq () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-vector-empty-sie_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-vector-empty-sie_xfail.f95
new file mode 100644
index 00000000000..2bf054ede56
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-vector-empty-sie_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel loop vector () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-vector-identifier-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-vector-identifier-without-bracket_xfail.f95
new file mode 100644
index 00000000000..f62c7e26ef1
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-vector-identifier-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel loop vector (x1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-vector-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-vector-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..6e89c5ecdfb
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-vector-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel loop vector (10 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-worker-empty-sie_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-worker-empty-sie_xfail.f95
new file mode 100644
index 00000000000..359b6ecd799
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-worker-empty-sie_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel loop worker () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-worker-identifier-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-worker-identifier-without-bracket_xfail.f95
new file mode 100644
index 00000000000..e26e509220b
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-worker-identifier-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel loop worker (x1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/parallel_loop-worker-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-worker-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..4dcbab861b3
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/parallel_loop-worker-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,18 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel loop worker (10 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/present-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/present-array-pointer.f95
new file mode 100644
index 00000000000..25dece6a595
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present-array-pointer.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel present (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels present (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "present" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/present-identifier-and-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/present-identifier-and-array-pointer.f95
new file mode 100644
index 00000000000..7781cac0dc5
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present-identifier-and-array-pointer.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data present (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel present (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels present (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "present" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/present-identifiers.f95 b/gcc/testsuite/gfortran.dg/gacc/present-identifiers.f95
new file mode 100644
index 00000000000..b796f17059a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present-identifiers.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data present (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel present (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels present (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "present" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/present-integer-literal-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/present-integer-literal-and-identifier_xfail.f95
new file mode 100644
index 00000000000..db6a002cb24
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present-integer-literal-and-identifier_xfail.f95
@@ -0,0 +1,27 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc parallel present (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc kernels present (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/present-integer-literal_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/present-integer-literal_xfail.f95
new file mode 100644
index 00000000000..5d5f6589bd0
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present-integer-literal_xfail.f95
@@ -0,0 +1,27 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc parallel present (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc kernels present (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/present-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/present-pointer.f95
new file mode 100644
index 00000000000..c8b8b09b84a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present-pointer.f95
@@ -0,0 +1,38 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+	integer, pointer :: y
+	integer, target :: x2 = 4
+	y => x2
+
+!$acc data present (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel present (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels present (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "present" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/present_or_copy-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/present_or_copy-array-pointer.f95
new file mode 100644
index 00000000000..a7b7519392d
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present_or_copy-array-pointer.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_copy (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel present_or_copy (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels present_or_copy (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "present_or_copy" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/present_or_copy-identifier-and-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/present_or_copy-identifier-and-array-pointer.f95
new file mode 100644
index 00000000000..14fef63dfcf
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present_or_copy-identifier-and-array-pointer.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data present_or_copy (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel present_or_copy (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels present_or_copy (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "present_or_copy" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/present_or_copy-identifiers.f95 b/gcc/testsuite/gfortran.dg/gacc/present_or_copy-identifiers.f95
new file mode 100644
index 00000000000..fcb2b7c67c7
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present_or_copy-identifiers.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data present_or_copy (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel present_or_copy (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels present_or_copy (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "present_or_copy" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/present_or_copy-integer-literal-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/present_or_copy-integer-literal-and-identifier_xfail.f95
new file mode 100644
index 00000000000..efa2eb5495d
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present_or_copy-integer-literal-and-identifier_xfail.f95
@@ -0,0 +1,27 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_copy (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc parallel present_or_copy (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc kernels present_or_copy (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/present_or_copy-integer-literal_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/present_or_copy-integer-literal_xfail.f95
new file mode 100644
index 00000000000..232071126f3
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present_or_copy-integer-literal_xfail.f95
@@ -0,0 +1,27 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_copy (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc parallel present_or_copy (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc kernels present_or_copy (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/present_or_copy-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/present_or_copy-pointer.f95
new file mode 100644
index 00000000000..7e60bc0a7e1
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present_or_copy-pointer.f95
@@ -0,0 +1,38 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+	integer, pointer :: y
+	integer, target :: x2 = 4
+	y => x2
+
+!$acc data present_or_copy (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel present_or_copy (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels present_or_copy (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "present_or_copy" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/present_or_copyin-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/present_or_copyin-array-pointer.f95
new file mode 100644
index 00000000000..62c98687b91
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present_or_copyin-array-pointer.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_copyin (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel present_or_copyin (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels present_or_copyin (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "present_or_copyin" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/present_or_copyin-identifier-and-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/present_or_copyin-identifier-and-array-pointer.f95
new file mode 100644
index 00000000000..d63b8251643
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present_or_copyin-identifier-and-array-pointer.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data present_or_copyin (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel present_or_copyin (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels present_or_copyin (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "present_or_copyin" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/present_or_copyin-identifiers.f95 b/gcc/testsuite/gfortran.dg/gacc/present_or_copyin-identifiers.f95
new file mode 100644
index 00000000000..d5cf79aa367
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present_or_copyin-identifiers.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data present_or_copyin (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel present_or_copyin (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels present_or_copyin (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "present_or_copyin" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/present_or_copyin-integer-literal-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/present_or_copyin-integer-literal-and-identifier_xfail.f95
new file mode 100644
index 00000000000..e9cde4a287f
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present_or_copyin-integer-literal-and-identifier_xfail.f95
@@ -0,0 +1,27 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_copyin (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc parallel present_or_copyin (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc kernels present_or_copyin (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/present_or_copyin-integer-literal_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/present_or_copyin-integer-literal_xfail.f95
new file mode 100644
index 00000000000..abbb67e03da
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present_or_copyin-integer-literal_xfail.f95
@@ -0,0 +1,27 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_copyin (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc parallel present_or_copyin (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc kernels present_or_copyin (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/present_or_copyin-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/present_or_copyin-pointer.f95
new file mode 100644
index 00000000000..b9d289e6a44
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present_or_copyin-pointer.f95
@@ -0,0 +1,38 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+	integer, pointer :: y
+	integer, target :: x2 = 4
+	y => x2
+
+!$acc data present_or_copyin (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel present_or_copyin (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels present_or_copyin (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "present_or_copyin" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/present_or_copyout-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/present_or_copyout-array-pointer.f95
new file mode 100644
index 00000000000..89c047f2e73
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present_or_copyout-array-pointer.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_copyout (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel present_or_copyout (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels present_or_copyout (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "present_or_copyout" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/present_or_copyout-identifier-and-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/present_or_copyout-identifier-and-array-pointer.f95
new file mode 100644
index 00000000000..8b6088c97b9
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present_or_copyout-identifier-and-array-pointer.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data present_or_copyout (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel present_or_copyout (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels present_or_copyout (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "present_or_copyout" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/present_or_copyout-identifiers.f95 b/gcc/testsuite/gfortran.dg/gacc/present_or_copyout-identifiers.f95
new file mode 100644
index 00000000000..fd27a19f18d
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present_or_copyout-identifiers.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data present_or_copyout (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel present_or_copyout (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels present_or_copyout (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "present_or_copyout" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/present_or_copyout-integer-literal-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/present_or_copyout-integer-literal-and-identifier_xfail.f95
new file mode 100644
index 00000000000..9a980824bd4
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present_or_copyout-integer-literal-and-identifier_xfail.f95
@@ -0,0 +1,27 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_copyout (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc parallel present_or_copyout (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc kernels present_or_copyout (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/present_or_copyout-integer-literal_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/present_or_copyout-integer-literal_xfail.f95
new file mode 100644
index 00000000000..ac333f54895
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present_or_copyout-integer-literal_xfail.f95
@@ -0,0 +1,27 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_copyout (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc parallel present_or_copyout (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc kernels present_or_copyout (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/present_or_copyout-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/present_or_copyout-pointer.f95
new file mode 100644
index 00000000000..dd2ee6646c8
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present_or_copyout-pointer.f95
@@ -0,0 +1,38 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+	integer, pointer :: y
+	integer, target :: x2 = 4
+	y => x2
+
+!$acc data present_or_copyout (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel present_or_copyout (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels present_or_copyout (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "present_or_copyout" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/present_or_create-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/present_or_create-array-pointer.f95
new file mode 100644
index 00000000000..5ba5832c0b3
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present_or_create-array-pointer.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_create (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel present_or_create (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels present_or_create (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "present_or_create" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/present_or_create-identifier-and-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/present_or_create-identifier-and-array-pointer.f95
new file mode 100644
index 00000000000..d1505741fff
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present_or_create-identifier-and-array-pointer.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data present_or_create (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel present_or_create (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels present_or_create (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "present_or_create" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/present_or_create-identifiers.f95 b/gcc/testsuite/gfortran.dg/gacc/present_or_create-identifiers.f95
new file mode 100644
index 00000000000..07cbb0dc5e9
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present_or_create-identifiers.f95
@@ -0,0 +1,35 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc data present_or_create (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel present_or_create (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels present_or_create (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "present_or_create" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
diff --git a/gcc/testsuite/gfortran.dg/gacc/present_or_create-integer-literal-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/present_or_create-integer-literal-and-identifier_xfail.f95
new file mode 100644
index 00000000000..2a1055cb62c
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present_or_create-integer-literal-and-identifier_xfail.f95
@@ -0,0 +1,27 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_create (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc parallel present_or_create (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc kernels present_or_create (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/present_or_create-integer-literal_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/present_or_create-integer-literal_xfail.f95
new file mode 100644
index 00000000000..48051d9e61d
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present_or_create-integer-literal_xfail.f95
@@ -0,0 +1,27 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc data present_or_create (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc parallel present_or_create (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc kernels present_or_create (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/present_or_create-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/present_or_create-pointer.f95
new file mode 100644
index 00000000000..b742e2b44ac
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/present_or_create-pointer.f95
@@ -0,0 +1,38 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+	integer, pointer :: y
+	integer, target :: x2 = 4
+	y => x2
+
+!$acc data present_or_create (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end data
+
+!$acc parallel present_or_create (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc kernels present_or_create (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+end program test
+! { dg-final { scan-tree-dump "data" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "present_or_create" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/private-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/private-array-pointer.f95
new file mode 100644
index 00000000000..3289b03a3c3
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/private-array-pointer.f95
@@ -0,0 +1,52 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop private (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop private (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel private (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop private (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+!$acc parallel   
+!$acc loop private (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "private" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/private-identifier-and-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/private-identifier-and-array-pointer.f95
new file mode 100644
index 00000000000..8316f2f333b
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/private-identifier-and-array-pointer.f95
@@ -0,0 +1,52 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels   
+!$acc loop private (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop private (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel private (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop private (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+!$acc parallel   
+!$acc loop private (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "private" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/private-identifiers.f95 b/gcc/testsuite/gfortran.dg/gacc/private-identifiers.f95
new file mode 100644
index 00000000000..862eafff279
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/private-identifiers.f95
@@ -0,0 +1,52 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels   
+!$acc loop private (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop private (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel private (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop private (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+!$acc parallel   
+!$acc loop private (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "private" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/private-integer-literal-and-identifier_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/private-integer-literal-and-identifier_xfail.f95
new file mode 100644
index 00000000000..3b007442b75
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/private-integer-literal-and-identifier_xfail.f95
@@ -0,0 +1,43 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop private (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop private (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc parallel private (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc parallel loop private (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc parallel   
+!$acc loop private (10, x1) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/private-integer-literal_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/private-integer-literal_xfail.f95
new file mode 100644
index 00000000000..0bdbc7c153e
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/private-integer-literal_xfail.f95
@@ -0,0 +1,43 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop private (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop private (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc parallel private (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc parallel loop private (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+!$acc parallel   
+!$acc loop private (10) ! { dg-error "Syntax error in OpenACC variable list" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/private-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/private-pointer.f95
new file mode 100644
index 00000000000..bf0dcf7a741
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/private-pointer.f95
@@ -0,0 +1,55 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+	integer, pointer :: y
+	integer, target :: x2 = 4
+	y => x2
+
+!$acc kernels   
+!$acc loop private (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop private (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel private (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop private (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+!$acc parallel   
+!$acc loop private (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "private" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/reduction-add-identifier-and-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/reduction-add-identifier-and-pointer.f95
new file mode 100644
index 00000000000..69100641557
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/reduction-add-identifier-and-pointer.f95
@@ -0,0 +1,55 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+	integer, pointer :: y
+	integer, target :: x2 = 4
+	y => x2
+
+!$acc kernels   
+!$acc loop reduction (+:x1,y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop reduction (+:x1,y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel reduction (+:x1,y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop reduction (+:x1,y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+!$acc parallel   
+!$acc loop reduction (+:x1,y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "reduction" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/reduction-add-identifiers.f95 b/gcc/testsuite/gfortran.dg/gacc/reduction-add-identifiers.f95
new file mode 100644
index 00000000000..92c7e35369d
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/reduction-add-identifiers.f95
@@ -0,0 +1,52 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels   
+!$acc loop reduction (+:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop reduction (+:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel reduction (+:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop reduction (+:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+!$acc parallel   
+!$acc loop reduction (+:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "reduction" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/reduction-binary-and-identifiers.f95 b/gcc/testsuite/gfortran.dg/gacc/reduction-binary-and-identifiers.f95
new file mode 100644
index 00000000000..e58557283bd
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/reduction-binary-and-identifiers.f95
@@ -0,0 +1,52 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels   
+!$acc loop reduction (.and.:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop reduction (.and.:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel reduction (.and.:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop reduction (.and.:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+!$acc parallel   
+!$acc loop reduction (.and.:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "reduction" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/reduction-binary-or-identifiers.f95 b/gcc/testsuite/gfortran.dg/gacc/reduction-binary-or-identifiers.f95
new file mode 100644
index 00000000000..490a1561b26
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/reduction-binary-or-identifiers.f95
@@ -0,0 +1,52 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels   
+!$acc loop reduction (.or.:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop reduction (.or.:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel reduction (.or.:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop reduction (.or.:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+!$acc parallel   
+!$acc loop reduction (.or.:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "reduction" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/reduction-binary-xor-identifiers.f95 b/gcc/testsuite/gfortran.dg/gacc/reduction-binary-xor-identifiers.f95
new file mode 100644
index 00000000000..8eff7e369e0
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/reduction-binary-xor-identifiers.f95
@@ -0,0 +1,52 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels   
+!$acc loop reduction (ieor:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop reduction (ieor:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel reduction (ieor:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop reduction (ieor:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+!$acc parallel   
+!$acc loop reduction (ieor:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "reduction" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/reduction-max-identifiers.f95 b/gcc/testsuite/gfortran.dg/gacc/reduction-max-identifiers.f95
new file mode 100644
index 00000000000..677a654d091
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/reduction-max-identifiers.f95
@@ -0,0 +1,52 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels   
+!$acc loop reduction (max:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop reduction (max:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel reduction (max:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop reduction (max:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+!$acc parallel   
+!$acc loop reduction (max:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "reduction" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/reduction-min-identifiers.f95 b/gcc/testsuite/gfortran.dg/gacc/reduction-min-identifiers.f95
new file mode 100644
index 00000000000..66d28b4b61a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/reduction-min-identifiers.f95
@@ -0,0 +1,52 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels   
+!$acc loop reduction (min:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop reduction (min:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel reduction (min:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop reduction (min:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+!$acc parallel   
+!$acc loop reduction (min:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "reduction" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/reduction-mult-identifiers.f95 b/gcc/testsuite/gfortran.dg/gacc/reduction-mult-identifiers.f95
new file mode 100644
index 00000000000..45612ad72e3
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/reduction-mult-identifiers.f95
@@ -0,0 +1,52 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc kernels   
+!$acc loop reduction (*:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop reduction (*:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel reduction (*:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop reduction (*:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+!$acc parallel   
+!$acc loop reduction (*:x1,x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "reduction" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/reduction-unary-add-identifier.f95 b/gcc/testsuite/gfortran.dg/gacc/reduction-unary-add-identifier.f95
new file mode 100644
index 00000000000..f8faccc75e1
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/reduction-unary-add-identifier.f95
@@ -0,0 +1,52 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop reduction (+:x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop reduction (+:x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel reduction (+:x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop reduction (+:x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+!$acc parallel   
+!$acc loop reduction (+:x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "reduction" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/reduction-unary-and-identifier.f95 b/gcc/testsuite/gfortran.dg/gacc/reduction-unary-and-identifier.f95
new file mode 100644
index 00000000000..af2589fa613
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/reduction-unary-and-identifier.f95
@@ -0,0 +1,52 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop reduction (iand:x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop reduction (iand:x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel reduction (iand:x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop reduction (iand:x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+!$acc parallel   
+!$acc loop reduction (iand:x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "reduction" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/reduction-unary-or-identifier.f95 b/gcc/testsuite/gfortran.dg/gacc/reduction-unary-or-identifier.f95
new file mode 100644
index 00000000000..a8e932d8e36
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/reduction-unary-or-identifier.f95
@@ -0,0 +1,52 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop reduction (ior:x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop reduction (ior:x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel reduction (ior:x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop reduction (ior:x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+!$acc parallel   
+!$acc loop reduction (ior:x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "reduction" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/reduction-unary-xor-identifier.f95 b/gcc/testsuite/gfortran.dg/gacc/reduction-unary-xor-identifier.f95
new file mode 100644
index 00000000000..e7a8518f73d
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/reduction-unary-xor-identifier.f95
@@ -0,0 +1,52 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop reduction (ieor:x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop reduction (ieor:x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel reduction (ieor:x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop reduction (ieor:x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+!$acc parallel   
+!$acc loop reduction (ieor:x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "reduction" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/seq-empty.f95 b/gcc/testsuite/gfortran.dg/gacc/seq-empty.f95
new file mode 100644
index 00000000000..c35101808c5
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/seq-empty.f95
@@ -0,0 +1,44 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop seq  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop seq  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel   
+!$acc loop seq  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop seq  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "seq" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/update-async-empty-sie_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/update-async-empty-sie_xfail.f95
new file mode 100644
index 00000000000..f7da49365f9
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/update-async-empty-sie_xfail.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc update async () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/update-async-identifier-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/update-async-identifier-without-bracket_xfail.f95
new file mode 100644
index 00000000000..072379bbde9
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/update-async-identifier-without-bracket_xfail.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc update async (x1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/update-async-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/update-async-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..14a8821b2cf
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/update-async-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc update async (10 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/update-device-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/update-device-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..45d51e4e28c
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/update-device-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc update device (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/update-device-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/update-device-empty-list_xfail.f95
new file mode 100644
index 00000000000..c6e6f01098c
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/update-device-empty-list_xfail.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc update device () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/update-device-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/update-device-empty_xfail.f95
new file mode 100644
index 00000000000..927621fa017
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/update-device-empty_xfail.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc update device  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/update-device-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/update-device-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..1f447895030
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/update-device-identifiers-without-comma_xfail.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc update device (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/update-host-array-pointer-without-right-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/update-host-array-pointer-without-right-bracket_xfail.f95
new file mode 100644
index 00000000000..98441a5eb9c
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/update-host-array-pointer-without-right-bracket_xfail.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc update host (a1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/update-host-empty-list_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/update-host-empty-list_xfail.f95
new file mode 100644
index 00000000000..728e1adc4d8
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/update-host-empty-list_xfail.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc update host () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/update-host-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/update-host-empty_xfail.f95
new file mode 100644
index 00000000000..ce46d428302
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/update-host-empty_xfail.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc update host  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/update-host-identifiers-without-comma_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/update-host-identifiers-without-comma_xfail.f95
new file mode 100644
index 00000000000..07e9f32d0fe
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/update-host-identifiers-without-comma_xfail.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc update host (x1 x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/update-if-array-limits_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/update-if-array-limits_xfail.f95
new file mode 100644
index 00000000000..0822a7fb044
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/update-if-array-limits_xfail.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc update if (a1(2:5)) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/update-if-empty_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/update-if-empty_xfail.f95
new file mode 100644
index 00000000000..86ba980c1b6
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/update-if-empty_xfail.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc update if  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/update-if-expresion-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/update-if-expresion-without-bracket_xfail.f95
new file mode 100644
index 00000000000..8ee5e618fd0
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/update-if-expresion-without-bracket_xfail.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc update if (1 == 0 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/update-if-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/update-if-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..7da8105ef95
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/update-if-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc update if 1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/update-if-white-space_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/update-if-white-space_xfail.f95
new file mode 100644
index 00000000000..3369bf10533
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/update-if-white-space_xfail.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc update if () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/use_device-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/use_device-array-pointer.f95
new file mode 100644
index 00000000000..f2d4e476380
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/use_device-array-pointer.f95
@@ -0,0 +1,19 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc host_data use_device (a1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end host_data
+
+end program test
+! { dg-final { scan-tree-dump "host_data" "original" } } 
+! { dg-final { scan-tree-dump "use_device" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/use_device-identifier-and-array-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/use_device-identifier-and-array-pointer.f95
new file mode 100644
index 00000000000..492bbeaa97b
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/use_device-identifier-and-array-pointer.f95
@@ -0,0 +1,19 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc host_data use_device (a1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end host_data
+
+end program test
+! { dg-final { scan-tree-dump "host_data" "original" } } 
+! { dg-final { scan-tree-dump "use_device" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/use_device-identifiers.f95 b/gcc/testsuite/gfortran.dg/gacc/use_device-identifiers.f95
new file mode 100644
index 00000000000..09abca056af
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/use_device-identifiers.f95
@@ -0,0 +1,19 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, x2 = 4, a1(10)
+
+!$acc host_data use_device (x1, x2) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end host_data
+
+end program test
+! { dg-final { scan-tree-dump "host_data" "original" } } 
+! { dg-final { scan-tree-dump "use_device" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/use_device-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/use_device-pointer.f95
new file mode 100644
index 00000000000..c564d4d4369
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/use_device-pointer.f95
@@ -0,0 +1,22 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+	integer, pointer :: y
+	integer, target :: x2 = 4
+	y => x2
+
+!$acc host_data use_device (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end host_data
+
+end program test
+! { dg-final { scan-tree-dump "host_data" "original" } } 
+! { dg-final { scan-tree-dump "use_device" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/vector-double.f95 b/gcc/testsuite/gfortran.dg/gacc/vector-double.f95
new file mode 100644
index 00000000000..e8d5200248b
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/vector-double.f95
@@ -0,0 +1,44 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop vector (1.5) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop vector (1.5) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel   
+!$acc loop vector (1.5) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop vector (1.5) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "vector" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/vector-empty.f95 b/gcc/testsuite/gfortran.dg/gacc/vector-empty.f95
new file mode 100644
index 00000000000..60182579c12
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/vector-empty.f95
@@ -0,0 +1,44 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop vector  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop vector  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel   
+!$acc loop vector  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop vector  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "vector" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/vector-identifier.f95 b/gcc/testsuite/gfortran.dg/gacc/vector-identifier.f95
new file mode 100644
index 00000000000..67fa8bd2215
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/vector-identifier.f95
@@ -0,0 +1,44 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop vector (x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop vector (x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel   
+!$acc loop vector (x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop vector (x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "vector" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/vector-integer-literal.f95 b/gcc/testsuite/gfortran.dg/gacc/vector-integer-literal.f95
new file mode 100644
index 00000000000..f2b1182f75c
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/vector-integer-literal.f95
@@ -0,0 +1,44 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop vector (10) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop vector (10) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel   
+!$acc loop vector (10) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop vector (10) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "vector" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/vector-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/vector-pointer.f95
new file mode 100644
index 00000000000..c71ca8c322c
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/vector-pointer.f95
@@ -0,0 +1,47 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+	integer, pointer :: y
+	integer, target :: x2 = 4
+	y => x2
+
+!$acc kernels   
+!$acc loop vector (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop vector (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel   
+!$acc loop vector (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop vector (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "vector" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/vector_length-double_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/vector_length-double_xfail.f95
new file mode 100644
index 00000000000..644cc0a663f
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/vector_length-double_xfail.f95
@@ -0,0 +1,16 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel vector_length (1.5) ! { dg-error "requires a scalar INTEGER expression" }
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/vector_length-identifier.f95 b/gcc/testsuite/gfortran.dg/gacc/vector_length-identifier.f95
new file mode 100644
index 00000000000..27bc8a90e85
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/vector_length-identifier.f95
@@ -0,0 +1,19 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel vector_length (x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "vector_length" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/vector_length-integer-literal.f95 b/gcc/testsuite/gfortran.dg/gacc/vector_length-integer-literal.f95
new file mode 100644
index 00000000000..ef220fba82e
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/vector_length-integer-literal.f95
@@ -0,0 +1,19 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc parallel vector_length (10) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "vector_length" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/vector_length-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/vector_length-pointer.f95
new file mode 100644
index 00000000000..380565af830
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/vector_length-pointer.f95
@@ -0,0 +1,22 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+	integer, pointer :: y
+	integer, target :: x2 = 4
+	y => x2
+
+!$acc parallel vector_length (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "vector_length" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/wait-double.f95 b/gcc/testsuite/gfortran.dg/gacc/wait-double.f95
new file mode 100644
index 00000000000..b49ca43efef
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/wait-double.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc wait (1.5) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
+! { dg-final { scan-tree-dump "wait" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/wait-empty.f95 b/gcc/testsuite/gfortran.dg/gacc/wait-empty.f95
new file mode 100644
index 00000000000..32045b22c75
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/wait-empty.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc wait  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
+! { dg-final { scan-tree-dump "wait" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/wait-identifier.f95 b/gcc/testsuite/gfortran.dg/gacc/wait-identifier.f95
new file mode 100644
index 00000000000..795e570c6a6
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/wait-identifier.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc wait (x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
+! { dg-final { scan-tree-dump "wait" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/wait-integer-literal.f95 b/gcc/testsuite/gfortran.dg/gacc/wait-integer-literal.f95
new file mode 100644
index 00000000000..2602c59742b
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/wait-integer-literal.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc wait (10) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
+! { dg-final { scan-tree-dump "wait" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/wait-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/wait-pointer.f95
new file mode 100644
index 00000000000..7b0815e85e3
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/wait-pointer.f95
@@ -0,0 +1,20 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+	integer, pointer :: y
+	integer, target :: x2 = 4
+	y => x2
+
+!$acc wait (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
+! { dg-final { scan-tree-dump "wait" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/wait-wait-empty-sie_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/wait-wait-empty-sie_xfail.f95
new file mode 100644
index 00000000000..9dbd247aec2
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/wait-wait-empty-sie_xfail.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc wait () 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/wait-wait-identifier-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/wait-wait-identifier-without-bracket_xfail.f95
new file mode 100644
index 00000000000..6562b4af815
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/wait-wait-identifier-without-bracket_xfail.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc wait (x1 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/wait-wait-integer-literal-without-bracket_xfail.f95 b/gcc/testsuite/gfortran.dg/gacc/wait-wait-integer-literal-without-bracket_xfail.f95
new file mode 100644
index 00000000000..8e9b9a4b54f
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/wait-wait-integer-literal-without-bracket_xfail.f95
@@ -0,0 +1,17 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+! { dg-xfail-if "" { *-*-* } { "*" } { "" } } 
+! { dg-error "" "" { xfail *-*-* } } 
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc wait (10 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+
+end program test
diff --git a/gcc/testsuite/gfortran.dg/gacc/worker-double.f95 b/gcc/testsuite/gfortran.dg/gacc/worker-double.f95
new file mode 100644
index 00000000000..999de875734
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/worker-double.f95
@@ -0,0 +1,44 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop worker (1.5) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop worker (1.5) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel   
+!$acc loop worker (1.5) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop worker (1.5) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "worker" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/worker-empty.f95 b/gcc/testsuite/gfortran.dg/gacc/worker-empty.f95
new file mode 100644
index 00000000000..512abb73e07
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/worker-empty.f95
@@ -0,0 +1,44 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop worker  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop worker  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel   
+!$acc loop worker  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop worker  
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "worker" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/worker-identifier.f95 b/gcc/testsuite/gfortran.dg/gacc/worker-identifier.f95
new file mode 100644
index 00000000000..5cb14a41936
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/worker-identifier.f95
@@ -0,0 +1,44 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop worker (x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop worker (x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel   
+!$acc loop worker (x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop worker (x1) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "worker" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/worker-integer-literal.f95 b/gcc/testsuite/gfortran.dg/gacc/worker-integer-literal.f95
new file mode 100644
index 00000000000..4620c297132
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/worker-integer-literal.f95
@@ -0,0 +1,44 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+
+!$acc kernels   
+!$acc loop worker (10) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop worker (10) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel   
+!$acc loop worker (10) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop worker (10) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "worker" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/testsuite/gfortran.dg/gacc/worker-pointer.f95 b/gcc/testsuite/gfortran.dg/gacc/worker-pointer.f95
new file mode 100644
index 00000000000..8958ae58bec
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gacc/worker-pointer.f95
@@ -0,0 +1,47 @@
+! { dg-do compile } 
+! { dg-options "-fopenacc -fdump-tree-original" } 
+
+program test
+	implicit none
+	integer i
+	integer :: x1 = 3, a1(10)
+	integer, pointer :: y
+	integer, target :: x2 = 4
+	y => x2
+
+!$acc kernels   
+!$acc loop worker (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels
+
+!$acc kernels loop worker (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end kernels loop
+
+!$acc parallel   
+!$acc loop worker (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel
+
+!$acc parallel loop worker (y) 
+	do i = 1,10
+		x1 = x1 + 1
+		a1(i) = x1
+	end do
+!$acc end parallel loop
+
+end program test
+! { dg-final { scan-tree-dump "parallel" "original" } } 
+! { dg-final { scan-tree-dump "kernels" "original" } } 
+! { dg-final { scan-tree-dump "loop" "original" } } 
+! { dg-final { scan-tree-dump "worker" "original" } } 
+! { dg-final { cleanup-tree-dump "original" } } 
\ No newline at end of file
diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c
index 70930a3592a..5422e444ed6 100644
--- a/gcc/tree-cfg.c
+++ b/gcc/tree-cfg.c
@@ -699,6 +699,17 @@ make_edges (void)
 	      }
 	      break;
 
+        case GIMPLE_ACC_PARALLEL:
+        case GIMPLE_ACC_KERNELS:
+        case GIMPLE_ACC_DATA:
+        case GIMPLE_ACC_CACHE:
+        case GIMPLE_ACC_WAIT:
+        case GIMPLE_ACC_HOST_DATA:
+        case GIMPLE_ACC_DECLARE:
+        case GIMPLE_ACC_UPDATE:
+        case GIMPLE_ACC_LOOP:
+          break;
+
 	    default:
 	      gcc_assert (!stmt_ends_bb_p (last));
 	      fallthru = true;
@@ -2279,6 +2290,11 @@ is_ctrl_altering_stmt (gimple t)
       /* OpenMP directives alter control flow.  */
       return true;
 
+    CASE_GIMPLE_ACC:
+      /* OpenACC directives alter control flow.  */
+      //return true;
+			return false;
+
     case GIMPLE_TRANSACTION:
       /* A transaction start alters control flow.  */
       return true;
@@ -4338,6 +4354,9 @@ verify_gimple_stmt (gimple stmt)
 	 how to setup the parallel iteration.  */
       return false;
 
+    CASE_GIMPLE_ACC:
+      return false;
+
     case GIMPLE_DEBUG:
       return verify_gimple_debug (stmt);
 
diff --git a/gcc/tree-core.h b/gcc/tree-core.h
index 69777dc2796..475e5468564 100644
--- a/gcc/tree-core.h
+++ b/gcc/tree-core.h
@@ -589,9 +589,50 @@ enum tree_node_kind {
   lang_decl,
   lang_type,
   omp_clause_kind,
+  acc_clause_kind,
   all_kinds
 };
 
+/* Number of operands and names for each clause.  */
+extern unsigned const char acc_clause_num_ops[];
+extern const char* const acc_clause_code_name[];
+
+/* Clause codes. Do not reorder.  */
+enum acc_clause_code
+{
+  /* Clause zero is special-cased inside the parser */
+  ACC_CLAUSE_ERROR = 0,
+  ACC_CLAUSE_IF,
+  ACC_CLAUSE_ASYNC,
+  ACC_CLAUSE_COLLAPSE,
+  ACC_CLAUSE_SEQ,
+  ACC_CLAUSE_INDEPENDENT,
+  ACC_CLAUSE_GANG,
+  ACC_CLAUSE_WORKER,
+  ACC_CLAUSE_VECTOR,
+  ACC_CLAUSE_NUM_GANGS,
+  ACC_CLAUSE_NUM_WORKERS,
+  ACC_CLAUSE_VECTOR_LENGTH,
+  ACC_CLAUSE_REDUCTION,
+  ACC_CLAUSE_COPY,
+  ACC_CLAUSE_COPYIN,
+  ACC_CLAUSE_COPYOUT,
+  ACC_CLAUSE_CREATE,
+  ACC_CLAUSE_PRESENT,
+  ACC_CLAUSE_PRESENT_OR_COPY,
+  ACC_CLAUSE_PRESENT_OR_COPYIN,
+  ACC_CLAUSE_PRESENT_OR_COPYOUT,
+  ACC_CLAUSE_PRESENT_OR_CREATE,
+  ACC_CLAUSE_HOST,
+  ACC_CLAUSE_DEVICE,
+  ACC_CLAUSE_DEVICEPTR,
+  ACC_CLAUSE_DEVICE_RESIDENT,
+  ACC_CLAUSE_USE_DEVICE,
+  ACC_CLAUSE_PRIVATE,
+  ACC_CLAUSE_FIRSTPRIVATE,
+  ACC_NO_CLAUSE_WAIT,
+  ACC_NO_CLAUSE_CACHE
+};
 
 /*---------------------------------------------------------------------------
                                 Type definitions
@@ -615,6 +656,7 @@ typedef tree (*walk_tree_lh) (tree *, int *, tree (*) (tree *, int *, void *),
 			      void *, struct pointer_set_t*);
 
 
+
 /*---------------------------------------------------------------------------
                               Main data structures
 ---------------------------------------------------------------------------*/
@@ -1084,6 +1126,32 @@ struct GTY(()) tree_omp_clause {
     ops[1];
 };
 
+/* Since OpenACC supports both fortran and C/C++,
+   we use the same constant */
+#define MAX_DIMENSIONS 7
+
+struct GTY(()) tree_acc_clause {
+    struct tree_common common;
+    location_t locus;
+    enum acc_clause_code code;
+    union acc_clause_subcode {
+        //enum acc_clause_default_kind  default_kind;
+        enum tree_code                reduction_code;
+        struct {
+            tree left[MAX_DIMENSIONS];
+            tree right[MAX_DIMENSIONS];
+            int dimensions;
+        } subarray;
+    } GTY ((skip)) subcode;
+
+    int is_subarray;
+
+    //gimple_seq gimple_reduction_init;
+    //gimple_seq gimple_reduction_merge;
+
+    tree GTY ((length ("acc_clause_num_ops[ACC_CLAUSE_CODE ((tree)&%h)]"))) ops[1];
+};
+
 struct GTY(()) tree_block {
   struct tree_base base;
   tree chain;
@@ -1483,6 +1551,7 @@ union GTY ((ptr_alias (union lang_tree_node),
   struct tree_statement_list GTY ((tag ("TS_STATEMENT_LIST"))) stmt_list;
   struct tree_constructor GTY ((tag ("TS_CONSTRUCTOR"))) constructor;
   struct tree_omp_clause GTY ((tag ("TS_OMP_CLAUSE"))) omp_clause;
+  struct tree_acc_clause GTY ((tag ("TS_ACC_CLAUSE"))) acc_clause;
   struct tree_optimization_option GTY ((tag ("TS_OPTIMIZATION"))) optimization;
   struct tree_target_option GTY ((tag ("TS_TARGET_OPTION"))) target_option;
 };
diff --git a/gcc/tree-dump.c b/gcc/tree-dump.c
index 12a2be7e49e..13c91a1250a 100644
--- a/gcc/tree-dump.c
+++ b/gcc/tree-dump.c
@@ -711,10 +711,18 @@ dequeue_and_dump (dump_info_p di)
       break;
     case OMP_CLAUSE:
       {
-	int i;
-	fprintf (di->stream, "%s\n", omp_clause_code_name[OMP_CLAUSE_CODE (t)]);
-	for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (t)]; i++)
-	  dump_child ("op: ", OMP_CLAUSE_OPERAND (t, i));
+        int i;
+        fprintf (di->stream, "%s\n", omp_clause_code_name[OMP_CLAUSE_CODE (t)]);
+        for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (t)]; i++)
+          dump_child ("op: ", OMP_CLAUSE_OPERAND (t, i));
+      }
+      break;
+    case ACC_CLAUSE:
+      {
+        int i;
+        fprintf (di->stream, "%s\n", acc_clause_code_name[ACC_CLAUSE_CODE (t)]);
+        for (i = 0; i < acc_clause_num_ops[ACC_CLAUSE_CODE (t)]; i++)
+          dump_child ("op: ", ACC_CLAUSE_OPERAND (t, i));
       }
       break;
     default:
diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
index ebb4b918813..566b60b410e 100644
--- a/gcc/tree-inline.c
+++ b/gcc/tree-inline.c
@@ -3839,6 +3839,21 @@ estimate_num_insns (gimple stmt, eni_weights *weights)
       return (weights->tm_cost
 	      + estimate_num_insns_seq (gimple_transaction_body (stmt),
 					weights));
+    
+    case GIMPLE_ACC_KERNELS:
+			return weights->acc_cost;
+		case GIMPLE_ACC_PARALLEL:
+    /*case GIMPLE_ACC_KERNELS:*/
+    case GIMPLE_ACC_DATA:
+    case GIMPLE_ACC_CACHE:
+    case GIMPLE_ACC_WAIT:
+    case GIMPLE_ACC_HOST_DATA:
+    case GIMPLE_ACC_DECLARE:
+    case GIMPLE_ACC_UPDATE:
+    case GIMPLE_ACC_LOOP:
+      return (weights->acc_cost
+				+ (gimple_acc_body(stmt) ? estimate_num_insns_seq (gimple_acc_body (stmt), weights) : 1000));
+
 
     default:
       gcc_unreachable ();
diff --git a/gcc/tree-inline.h b/gcc/tree-inline.h
index a78e4b69f0e..8193863adce 100644
--- a/gcc/tree-inline.h
+++ b/gcc/tree-inline.h
@@ -152,6 +152,9 @@ typedef struct eni_weights_d
   /* Cost for omp construct.  */
   unsigned omp_cost;
 
+  /* Cost for acc construct.  */
+  unsigned acc_cost;
+
   /* Cost for tm transaction.  */
   unsigned tm_cost;
 
diff --git a/gcc/tree-pass.h b/gcc/tree-pass.h
index ea1a62f4368..3bee09d16b4 100644
--- a/gcc/tree-pass.h
+++ b/gcc/tree-pass.h
@@ -449,6 +449,9 @@ extern gimple_opt_pass *make_pass_split_functions (gcc::context *ctxt);
 extern gimple_opt_pass *make_pass_feedback_split_functions (gcc::context *ctxt);
 extern gimple_opt_pass *make_pass_strength_reduction (gcc::context *ctxt);
 extern gimple_opt_pass *make_pass_vtable_verify (gcc::context *ctxt);
+extern gimple_opt_pass *make_pass_lower_oacc (gcc::context *ctxt);
+extern gimple_opt_pass *make_pass_expand_oacc (gcc::context *ctxt);
+extern gimple_opt_pass *make_pass_diagnose_oacc_blocks (gcc::context *ctxt);
 
 /* IPA Passes */
 extern simple_ipa_opt_pass *make_pass_ipa_lower_emutls (gcc::context *ctxt);
diff --git a/gcc/tree-pretty-print.c b/gcc/tree-pretty-print.c
index 4c0481669ef..d040d52d1f2 100644
--- a/gcc/tree-pretty-print.c
+++ b/gcc/tree-pretty-print.c
@@ -51,6 +51,239 @@ static void do_niy (pretty_printer *, const_tree);
 static pretty_printer buffer;
 static int initialized = 0;
 
+unsigned char
+dump_acc_body(int flags, tree node, int spc,
+              unsigned char is_expr, pretty_printer* buffer)
+{
+	if (!(flags & TDF_SLIM)&& ACC_BODY (node))
+	{
+		newline_and_indent(buffer, spc + 2);
+		pp_character(buffer, '{');
+		newline_and_indent(buffer, spc + 4);
+		dump_generic_node(buffer, ACC_BODY (node), spc + 4, flags, false);
+		newline_and_indent(buffer, spc + 2);
+		pp_character(buffer, '}');
+	}
+	is_expr = false;
+	return is_expr;
+}
+
+void
+dump_acc_clause_remap(const char* name, tree clause,
+                      int spc, int flags, pretty_printer* buffer)
+{
+  pp_string(buffer, name);
+  pp_character(buffer, '(');
+  dump_generic_node(buffer, ACC_CLAUSE_DECL (clause), spc, flags, false);
+  if (ACC_IS_SUBARRAY(clause))
+    {
+      int i;
+
+      pp_character(buffer, '(');
+      for (i = 0; i < ACC_SUBARRAY_DIMENSIONS(clause) - 1; i++)
+        {
+          dump_generic_node(buffer, ACC_SUBARRAY_LEFT_BOUND(clause, i), spc, flags, false);
+          pp_character(buffer, ':');
+          dump_generic_node(buffer, ACC_SUBARRAY_RIGHT_BOUND(clause, i), spc, flags, false);
+          pp_character(buffer, ',');
+        }
+
+      dump_generic_node(buffer, ACC_SUBARRAY_LEFT_BOUND(clause, i), spc, flags, false);
+      pp_character(buffer, ':');
+      dump_generic_node(buffer, ACC_SUBARRAY_RIGHT_BOUND(clause, i), spc, flags, false);
+      pp_character(buffer, ')');
+    }
+  pp_character(buffer, ')');
+}
+
+void
+dump_acc_clause (pretty_printer *buffer, tree clause, int spc, int flags)
+{
+  const char *name;
+  enum acc_clause_code clause_code;
+
+  if (clause == NULL)
+    return;
+
+  clause_code = ACC_CLAUSE_CODE(clause);
+
+  switch (clause_code)
+    {
+    case ACC_CLAUSE_ASYNC:
+      name = "async";
+      pp_string(buffer, name);
+      dump_generic_node(buffer, ACC_CLAUSE_DECL (clause), spc, flags, false);
+      break;
+    case ACC_CLAUSE_VECTOR:
+      name = "vector";
+      pp_string(buffer, name);
+      dump_generic_node(buffer, ACC_CLAUSE_DECL (clause), spc, flags, false);
+      break;
+    case ACC_CLAUSE_GANG:
+      name = "gang";
+      pp_string(buffer, name);
+      dump_generic_node(buffer, ACC_CLAUSE_DECL (clause), spc, flags, false);
+      break;
+    case ACC_CLAUSE_WORKER:
+      name = "worker";
+      pp_string(buffer, name);
+      dump_generic_node(buffer, ACC_CLAUSE_DECL (clause), spc, flags, false);
+      break;
+    case ACC_CLAUSE_INDEPENDENT:
+      name = "independent";
+      pp_string(buffer, name);
+      break;
+    case ACC_CLAUSE_SEQ:
+      name = "seq";
+      pp_string(buffer, name);
+      break;
+    case ACC_CLAUSE_COPY:
+      name = "copy";
+      dump_acc_clause_remap(name, clause, spc, flags, buffer);
+      break;
+    case ACC_CLAUSE_COPYIN:
+      name = "copyin";
+      dump_acc_clause_remap(name, clause, spc, flags, buffer);
+      break;
+    case ACC_CLAUSE_COPYOUT:
+      name = "copyout";
+      dump_acc_clause_remap(name, clause, spc, flags, buffer);
+      break;
+    case ACC_CLAUSE_CREATE:
+      name = "create";
+      dump_acc_clause_remap(name, clause, spc, flags, buffer);
+      break;
+    case ACC_CLAUSE_PRESENT:
+      name = "present";
+      dump_acc_clause_remap(name, clause, spc, flags, buffer);
+      break;
+    case ACC_CLAUSE_PRESENT_OR_COPY:
+      name = "present_or_copy";
+      dump_acc_clause_remap(name, clause, spc, flags, buffer);
+      break;
+    case ACC_CLAUSE_PRESENT_OR_COPYIN:
+      name = "present_or_copyin";
+      dump_acc_clause_remap(name, clause, spc, flags, buffer);
+      break;
+    case ACC_CLAUSE_PRESENT_OR_COPYOUT:
+      name = "present_or_copyout";
+      dump_acc_clause_remap(name, clause, spc, flags, buffer);
+      break;
+    case ACC_CLAUSE_PRESENT_OR_CREATE:
+      name = "present_or_create";
+      dump_acc_clause_remap(name, clause, spc, flags, buffer);
+      break;
+    case ACC_CLAUSE_FIRSTPRIVATE:
+      name = "firstprivate";
+      dump_acc_clause_remap(name, clause, spc, flags, buffer);
+      break;
+    case ACC_CLAUSE_PRIVATE:
+      name = "private";
+      dump_acc_clause_remap(name, clause, spc, flags, buffer);
+      break;
+    case ACC_CLAUSE_DEVICEPTR:
+      name = "deviceptr";
+      dump_acc_clause_remap(name, clause, spc, flags, buffer);
+      break;
+    case ACC_CLAUSE_USE_DEVICE:
+      name = "use_device";
+      dump_acc_clause_remap(name, clause, spc, flags, buffer);
+      break;
+    case ACC_CLAUSE_DEVICE_RESIDENT:
+      name = "device_resident";
+      dump_acc_clause_remap(name, clause, spc, flags, buffer);
+      break;
+    case ACC_CLAUSE_HOST:
+      name = "host";
+      dump_acc_clause_remap(name, clause, spc, flags, buffer);
+      break;
+    case ACC_CLAUSE_DEVICE:
+      name = "device";
+      dump_acc_clause_remap(name, clause, spc, flags, buffer);
+      break;
+    case ACC_NO_CLAUSE_CACHE:
+      name = "";
+      dump_acc_clause_remap(name, clause, spc, flags, buffer);
+      break;
+
+    case ACC_CLAUSE_REDUCTION:
+      pp_string (buffer, "reduction(");
+      pp_string (buffer, op_symbol_code (ACC_CLAUSE_REDUCTION_CODE (clause)));
+      pp_character (buffer, ':');
+      dump_generic_node (buffer, ACC_CLAUSE_DECL (clause),
+	  spc, flags, false);
+      pp_character (buffer, ')');
+      break;
+
+    case ACC_CLAUSE_IF:
+      pp_string (buffer, "if(");
+      dump_generic_node (buffer, ACC_CLAUSE_IF_EXPR (clause),
+                         spc, flags, false);
+      pp_character (buffer, ')');
+      break;
+
+    case ACC_CLAUSE_NUM_GANGS:
+      pp_string (buffer, "num_gangs(");
+      dump_generic_node (buffer, ACC_CLAUSE_NUM_GANGS_EXPR (clause),
+                         spc, flags, false);
+      pp_character (buffer, ')');
+      break;
+    case ACC_CLAUSE_NUM_WORKERS:
+      pp_string (buffer, "num_workers(");
+      dump_generic_node (buffer, ACC_CLAUSE_NUM_WORKERS_EXPR (clause),
+                         spc, flags, false);
+      pp_character (buffer, ')');
+      break;
+    case ACC_CLAUSE_VECTOR_LENGTH:
+      pp_string (buffer, "vector_length(");
+      dump_generic_node (buffer, ACC_CLAUSE_VECTOR_LENGTH_EXPR (clause),
+                         spc, flags, false);
+      pp_character (buffer, ')');
+      break;
+
+    case ACC_CLAUSE_COLLAPSE:
+      pp_string (buffer, "collapse(");
+      dump_generic_node (buffer, ACC_CLAUSE_COLLAPSE_EXPR (clause),
+                         spc, flags, false);
+      pp_character (buffer, ')');
+      break;
+    case ACC_NO_CLAUSE_WAIT:
+      pp_string (buffer, "(");
+      dump_generic_node (buffer, ACC_WAIT_EXPR (clause),
+                         spc, flags, false);
+      pp_character (buffer, ')');
+      break;
+
+
+/*
+    case ACC_CLAUSE_:
+      pp_string (buffer, "");
+      break;
+*/
+    default:
+      name = "unreconised_acc_clause";
+      dump_acc_clause_remap(name, clause, spc, flags, buffer);
+      break;
+    }
+}
+
+void
+dump_acc_clauses (pretty_printer *buffer, tree clause, int spc, int flags)
+{
+  if (clause == NULL)
+    return;
+
+  pp_space (buffer);
+  while (1)
+  {
+    dump_acc_clause (buffer, clause, spc, flags);
+    clause = ACC_CLAUSE_CHAIN (clause);
+    if (clause == NULL)
+      return;
+    pp_space (buffer);
+  }
+}
+
 /* Try to print something for an unknown tree code.  */
 
 static void
@@ -2332,6 +2565,109 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       is_expr = false;
       break;
 
+    case ACC_PARALLEL:
+      pp_string (buffer, "#pragma acc parallel");
+      dump_acc_clauses (buffer, ACC_PARALLEL_CLAUSES (node), spc, flags);
+      is_expr = dump_acc_body(flags, node, spc, is_expr, buffer);
+
+      break;
+    case ACC_KERNELS:
+      pp_string (buffer, "#pragma acc kernels");
+      dump_acc_clauses (buffer, ACC_KERNELS_CLAUSES(node), spc, flags);
+      is_expr = dump_acc_body(flags, node, spc, is_expr, buffer);
+
+      break;
+    case ACC_LOOP:
+      pp_string (buffer, "#pragma acc loop");
+      dump_acc_clauses (buffer, ACC_LOOP_CLAUSES(node), spc, flags);
+      if (!(flags & TDF_SLIM))
+        {
+          int i;
+
+          if (ACC_LOOP_PRE_BODY (node))
+            {
+              newline_and_indent (buffer, spc + 2);
+              pp_character (buffer, '{');
+              spc += 4;
+              newline_and_indent (buffer, spc);
+              dump_generic_node (buffer, ACC_LOOP_PRE_BODY (node),
+                  spc, flags, false);
+            }
+          spc -= 2;
+          for (i = 0; i < TREE_VEC_LENGTH (ACC_LOOP_INIT (node)); i++)
+            {
+              spc += 2;
+              newline_and_indent (buffer, spc);
+              pp_string (buffer, "for (");
+              dump_generic_node (buffer, TREE_VEC_ELT (ACC_LOOP_INIT (node), i),
+                                 spc, flags, false);
+              pp_string (buffer, "; ");
+              dump_generic_node (buffer, TREE_VEC_ELT (ACC_LOOP_COND (node), i),
+                                 spc, flags, false);
+              pp_string (buffer, "; ");
+              dump_generic_node (buffer, TREE_VEC_ELT (ACC_LOOP_INCR (node), i),
+                                 spc, flags, false);
+              pp_string (buffer, ")");
+            }
+          if (ACC_LOOP_BODY (node))
+            {
+              newline_and_indent (buffer, spc + 2);
+              pp_character (buffer, '{');
+              newline_and_indent (buffer, spc + 4);
+              dump_generic_node (buffer, ACC_LOOP_BODY (node), spc + 4, flags,
+                  false);
+              newline_and_indent (buffer, spc + 2);
+              pp_character (buffer, '}');
+            }
+          spc -= 2 * TREE_VEC_LENGTH (ACC_LOOP_INIT (node)) - 2;
+          if (ACC_LOOP_PRE_BODY (node))
+            {
+              spc -= 4;
+              newline_and_indent (buffer, spc + 2);
+              pp_character (buffer, '}');
+            }
+        }
+      is_expr = false;
+
+      break;
+    case ACC_HOST_DATA:
+      pp_string (buffer, "#pragma acc host_data");
+      dump_acc_clauses (buffer, ACC_HOST_DATA_CLAUSES(node), spc, flags);
+      is_expr = dump_acc_body(flags, node, spc, is_expr, buffer);
+
+      break;
+    case ACC_DATA:
+      pp_string (buffer, "#pragma acc data");
+      dump_acc_clauses (buffer, ACC_DATA_CLAUSES(node), spc, flags);
+      is_expr = dump_acc_body(flags, node, spc, is_expr, buffer);
+
+      break;
+    case ACC_WAIT:
+      pp_string (buffer, "#pragma acc wait");
+      dump_acc_clauses (buffer, ACC_WAIT_CLAUSES(node), spc, flags);
+
+      break;
+    case ACC_UPDATE:
+      pp_string (buffer, "#pragma acc update");
+      dump_acc_clauses (buffer, ACC_UPDATE_CLAUSES(node), spc, flags);
+
+      break;
+    case ACC_DECLARE:
+      pp_string (buffer, "#pragma acc declare");
+      dump_acc_clauses (buffer, ACC_DECLARE_CLAUSES(node), spc, flags);
+
+      break;
+    case ACC_CACHE:
+      pp_string (buffer, "#pragma acc cache");
+      dump_acc_clauses (buffer, ACC_CACHE_CLAUSES(node), spc, flags);
+
+      break;
+    case ACC_CLAUSE:
+      dump_acc_clause (buffer, node, spc, flags);
+      is_expr = false;
+
+      break;
+
     case TRANSACTION_EXPR:
       if (TRANSACTION_EXPR_OUTER (node))
 	pp_string (buffer, "__transaction_atomic [[outer]]");
diff --git a/gcc/tree-pretty-print.h b/gcc/tree-pretty-print.h
index 7da8000d5b8..179f0c35177 100644
--- a/gcc/tree-pretty-print.h
+++ b/gcc/tree-pretty-print.h
@@ -32,7 +32,13 @@ along with GCC; see the file COPYING3.  If not see
 
 extern void pp_tree_identifier (pretty_printer *, tree);
 
+
 /* In tree-pretty-print.c  */
+extern unsigned char dump_acc_body
+                        (int, tree, int, unsigned char, pretty_printer*);
+extern void dump_acc_clause_remap
+                        (const char*, tree, int, int, pretty_printer*);
+extern void dump_acc_clause (pretty_printer *, tree, int, int);
 extern void print_declaration (pretty_printer *, tree, int, int);
 extern int dump_generic_node (pretty_printer *, tree, int, int, bool);
 extern void print_generic_stmt (FILE *, tree, int);
diff --git a/gcc/tree.c b/gcc/tree.c
index 6593cf82018..18ca753d610 100644
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -143,6 +143,7 @@ static const char * const tree_node_kind_names[] = {
   "lang_decl kinds",
   "lang_type kinds",
   "omp clauses",
+  "acc clauses"
 };
 
 /* Unique id for next decl created.  */
@@ -278,6 +279,74 @@ const char * const omp_clause_code_name[] =
   "_simduid_"
 };
 
+/* Number of operands for each OpenACC clause.  */
+/* TODO On first view - is okay, but number of operand maybe incorrect,
+ * because this values accounts only single values
+ * On my view, 3 - for ranges is okay. Evgeny Gavrin */
+unsigned const char acc_clause_num_ops[] =
+{
+  0,  //  PRAGMA_ACC_CLAUSE_ERROR,
+  1,  //  PRAGMA_ACC_CLAUSE_IF,
+  1,  //  PRAGMA_ACC_CLAUSE_ASYNC,
+  3,  //  PRAGMA_ACC_CLAUSE_COLLAPSE,
+  0,  //  PRAGMA_ACC_CLAUSE_SEQ,
+  0,  //  PRAGMA_ACC_CLAUSE_INDEPENDENT,
+  1,  //  PRAGMA_ACC_CLAUSE_GANG,
+  1,  //  PRAGMA_ACC_CLAUSE_WORKER,
+  1,  //  PRAGMA_ACC_CLAUSE_VECTOR,
+  1,  //  PRAGMA_ACC_CLAUSE_NUM_GANGS,
+  1,  //  PRAGMA_ACC_CLAUSE_NUM_WORKERS,
+  1,  //  PRAGMA_ACC_CLAUSE_VECTOR_LENGTH,
+  4,  //  PRAGMA_ACC_CLAUSE_REDUCTION,
+  3,  //  PRAGMA_ACC_CLAUSE_COPY,
+  3,  //  PRAGMA_ACC_CLAUSE_COPYIN,
+  3,  //  PRAGMA_ACC_CLAUSE_COPYOUT,
+  3,  //  PRAGMA_ACC_CLAUSE_CREATE,
+  3,  //  PRAGMA_ACC_CLAUSE_PRESENT,
+  3,  //  PRAGMA_ACC_CLAUSE_PRESENT_OR_COPY,
+  3,  //  PRAGMA_ACC_CLAUSE_PRESENT_OR_COPYIN,
+  3,  //  PRAGMA_ACC_CLAUSE_PRESENT_OR_COPYOUT,
+  3,  //  PRAGMA_ACC_CLAUSE_PRESENT_OR_CREATE,
+  1,  //  PRAGMA_ACC_CLAUSE_HOST,
+  1,  //  PRAGMA_ACC_CLAUSE_DEVICE,
+  1,  //  PRAGMA_ACC_CLAUSE_DEVICEPTR,
+  1,  //  PRAGMA_ACC_CLAUSE_DEVICE_RESIDENT,
+  1,  //  PRAGMA_ACC_CLAUSE_USE_DEVICE,
+  3,  //  PRAGMA_ACC_CLAUSE_PRIVATE,
+  3   //  PRAGMA_ACC_CLAUSE_FIRSTPRIVATE
+};
+
+const char * const acc_clause_code_name[] =
+{
+  "if",
+  "async",
+  "collapse",
+  "seq",
+  "indepentend",
+  "gang",
+  "worker",
+  "vector",
+  "num_gangs",
+  "num_workers",
+  "vector_length",
+  "reduction",
+  "copy",
+  "copyin",
+  "copyout",
+  "create",
+  "present",
+  "present_or_copy",
+  "present_or_copyin",
+  "present_or_copyout",
+  "present_or_create",
+  "host",
+  "device",
+  "deviceptr",
+  "device_resident",
+  "use_device",
+  "private",
+  "firstprivate"
+};
 
 /* Return the tree node structure used by tree code CODE.  */
 
@@ -348,6 +417,7 @@ tree_node_structure_for_code (enum tree_code code)
     case CONSTRUCTOR:		return TS_CONSTRUCTOR;
     case TREE_BINFO:		return TS_BINFO;
     case OMP_CLAUSE:		return TS_OMP_CLAUSE;
+    case ACC_CLAUSE:		return TS_ACC_CLAUSE;
     case OPTIMIZATION_NODE:	return TS_OPTIMIZATION;
     case TARGET_OPTION_NODE:	return TS_TARGET_OPTION;
 
@@ -405,6 +475,7 @@ initialize_tree_contains_struct (void)
 	case TS_VEC:
 	case TS_BINFO:
 	case TS_OMP_CLAUSE:
+	case TS_ACC_CLAUSE:
 	case TS_OPTIMIZATION:
 	case TS_TARGET_OPTION:
 	  MARK_TS_COMMON (code);
@@ -693,7 +764,8 @@ tree_code_size (enum tree_code code)
 	case PLACEHOLDER_EXPR:	return sizeof (struct tree_common);
 
 	case TREE_VEC:
-	case OMP_CLAUSE:	gcc_unreachable ();
+        case OMP_CLAUSE:        gcc_unreachable ();
+        case ACC_CLAUSE:        gcc_unreachable ();
 
 	case SSA_NAME:		return sizeof (struct tree_ssa_name);
 
@@ -738,8 +810,13 @@ tree_size (const_tree node)
 
     case OMP_CLAUSE:
       return (sizeof (struct tree_omp_clause)
-	      + (omp_clause_num_ops[OMP_CLAUSE_CODE (node)] - 1)
-	        * sizeof (tree));
+              + (omp_clause_num_ops[OMP_CLAUSE_CODE (node)] - 1)
+                * sizeof (tree));
+
+    case ACC_CLAUSE:
+      return (sizeof (struct tree_acc_clause)
+              + (acc_clause_num_ops[ACC_CLAUSE_CODE (node)] - 1)
+                * sizeof (tree));
 
     default:
       if (TREE_CODE_CLASS (code) == tcc_vl_exp)
@@ -823,6 +900,10 @@ record_node_allocation_statistics (enum tree_code code ATTRIBUTE_UNUSED,
 	  kind = omp_clause_kind;
 	  break;
 
+	case ACC_CLAUSE:
+	  kind = acc_clause_kind;
+	  break;
+
 	default:
 	  kind = x_kind;
 	  break;
@@ -10367,6 +10448,29 @@ build_omp_clause (location_t loc, enum omp_clause_code code)
   return t;
 }
 
+
+/* Build an OpenACC clause with code CODE.  LOC is the location of the
+   clause.  */
+tree
+build_acc_clause (location_t loc, enum acc_clause_code code)
+{
+  tree t;
+  int size, length;
+
+  length = acc_clause_num_ops[code];
+  size = (sizeof (struct tree_acc_clause) + (length - 1) * sizeof (tree));
+
+  record_node_allocation_statistics (ACC_CLAUSE, size);
+
+  t = ggc_alloc_tree_node (size);
+  memset (t, 0, size);
+  TREE_SET_CODE (t, ACC_CLAUSE);
+  ACC_CLAUSE_SET_CODE (t, code);
+  ACC_CLAUSE_LOCATION (t) = loc;
+
+  return t;
+}
+
 /* Build a tcc_vl_exp object with code CODE and room for LEN operands.  LEN
    includes the implicit operand count in TREE_OPERAND 0, and so must be >= 1.
    Except for the CODE and operand count field, other storage for the
diff --git a/gcc/tree.def b/gcc/tree.def
index f825aad5355..77e86d49a15 100644
--- a/gcc/tree.def
+++ b/gcc/tree.def
@@ -995,6 +995,65 @@ DEFTREECODE (TARGET_MEM_REF, "target_mem_ref", tcc_reference, 5)
    chain of component references offsetting p by c.  */
 DEFTREECODE (MEM_REF, "mem_ref", tcc_reference, 2)
 
+/* OpenACC */
+/* 3rd param - num of statements */
+
+/* #pragma acc parallel */
+/* Operand 0: BODY
+   Operand 1: CLAUSES   
+*/
+DEFTREECODE (ACC_PARALLEL, "acc_parallel", tcc_statement, 2)
+
+/* #pragma acc kernels */
+/* Operand 0: BODY
+   Operand 1: CLAUSES   
+*/
+DEFTREECODE (ACC_KERNELS, "acc_kernels", tcc_statement, 2)
+
+/* #pragma acc data */
+/* Operand 0: BODY
+   Operand 1: CLAUSES   
+*/
+DEFTREECODE (ACC_DATA, "acc_data", tcc_statement, 2)
+
+/* #pragma acc loop */
+/* Operand 0: BODY
+   Operand 1: CLAUSES
+   Operand 2: INIT
+   Operand 3: COND
+   Operand 4: INCR
+   Operand 5: PRE_BODY
+*/
+DEFTREECODE (ACC_LOOP, "acc_loop", tcc_statement, 6)
+
+/* #pragma acc host_data */
+/* Operand 0: BODY
+   Operand 1: CLAUSES   
+*/
+DEFTREECODE (ACC_HOST_DATA, "acc_host_data", tcc_statement, 2)
+
+/* #pragma acc declare */
+/* Operand 0: CLAUSES   
+*/
+DEFTREECODE (ACC_DECLARE, "acc_declare", tcc_statement, 1)
+
+/* #pragma acc update */
+/* Operand 0: CLAUSES   
+*/
+DEFTREECODE (ACC_UPDATE, "acc_update", tcc_statement, 1)
+
+/* #pragma acc wait */
+/* Operand 0: INT_EXPR
+*/
+DEFTREECODE (ACC_WAIT, "acc_wait", tcc_statement, 1)
+
+/* #pragma acc cache */
+/* Operand 0: LIST
+*/
+DEFTREECODE (ACC_CACHE, "acc_cache", tcc_statement, 1)
+
+DEFTREECODE (ACC_CLAUSE, "acc_clause", tcc_exceptional, 1)
+
 /* The ordering of the codes between OMP_PARALLEL and OMP_CRITICAL is
    exposed to TREE_RANGE_CHECK.  */
 /* OpenMP - #pragma omp parallel [clause1 ... clauseN]
diff --git a/gcc/tree.h b/gcc/tree.h
index a263a2cf46a..5702c3036b5 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -1150,6 +1150,89 @@ extern void protected_set_expr_location (tree, location_t);
 #define TRANSACTION_EXPR_RELAXED(NODE) \
   (TRANSACTION_EXPR_CHECK (NODE)->base.public_flag)
 
+/* OpenACC directives and clause accessors. */
+#define ACC_BODY(NODE)                           TREE_OPERAND (NODE, 0)
+
+#define ACC_CLAUSE_CHAIN(NODE) \
+            ((NODE)->acc_clause.common.chain)
+
+#define ACC_CLAUSE(NODE) \
+            TREE_OPERAND (NODE, 0)
+
+#define ACC_CLAUSE_DECL(NODE) \
+            ((NODE)->acc_clause.ops[0])
+
+#define ACC_CLAUSE_CODE(NODE) \
+            ((NODE)->acc_clause.code)
+
+#define ACC_CLAUSE_OPERAND(T, i) \
+            ((T)->acc_clause.ops[i])
+
+#define ACC_CLAUSE_SET_CODE(NODE, CODE) \
+            ((NODE)->acc_clause.code = (CODE))
+
+#define ACC_CLAUSE_LOCATION(NODE) \
+            ((NODE)->acc_clause.locus)
+
+#define ACC_SUBARRAY_LEFT_BOUND(NODE, i) \
+            ((NODE)->acc_clause.subcode.subarray.left[i])
+
+#define ACC_SUBARRAY_RIGHT_BOUND(NODE, i) \
+            ((NODE)->acc_clause.subcode.subarray.right[i])
+
+#define ACC_SUBARRAY_DIMENSIONS(NODE) \
+            ((NODE)->acc_clause.subcode.subarray.dimensions)
+
+#define ACC_IS_SUBARRAY(NODE) \
+            ((NODE)->acc_clause.is_subarray)
+
+#define ACC_PARALLEL_BODY(NODE)      TREE_OPERAND (ACC_PARALLEL_CHECK(NODE), 0)
+#define ACC_PARALLEL_CLAUSES(NODE)   TREE_OPERAND (ACC_PARALLEL_CHECK(NODE), 1)
+
+#define ACC_KERNELS_BODY(NODE)       TREE_OPERAND (ACC_KERNELS_CHECK(NODE), 0)
+#define ACC_KERNELS_CLAUSES(NODE)    TREE_OPERAND (ACC_KERNELS_CHECK(NODE), 1)
+
+#define ACC_LOOP_BODY(NODE)          TREE_OPERAND (ACC_LOOP_CHECK (NODE), 0)
+#define ACC_LOOP_CLAUSES(NODE)       TREE_OPERAND (ACC_LOOP_CHECK (NODE), 1)
+#define ACC_LOOP_INIT(NODE)          TREE_OPERAND (ACC_LOOP_CHECK (NODE), 2)
+#define ACC_LOOP_COND(NODE)          TREE_OPERAND (ACC_LOOP_CHECK (NODE), 3)
+#define ACC_LOOP_INCR(NODE)          TREE_OPERAND (ACC_LOOP_CHECK (NODE), 4)
+#define ACC_LOOP_PRE_BODY(NODE)      TREE_OPERAND (ACC_LOOP_CHECK (NODE), 5)
+
+/* OpenACC clauses */
+#define ACC_CLAUSE_NUM_GANGS_EXPR(NODE)          ACC_CLAUSE_DECL (NODE)
+#define ACC_CLAUSE_NUM_WORKERS_EXPR(NODE)        ACC_CLAUSE_DECL (NODE)
+#define ACC_CLAUSE_VECTOR_LENGTH_EXPR(NODE)      ACC_CLAUSE_DECL (NODE)
+#define ACC_CLAUSE_VECTOR_EXPR(NODE)             ACC_CLAUSE_DECL (NODE)
+#define ACC_CLAUSE_WORKER_EXPR(NODE)             ACC_CLAUSE_DECL (NODE)
+#define ACC_CLAUSE_GANG_EXPR(NODE)               ACC_CLAUSE_DECL (NODE)
+#define ACC_CLAUSE_COLLAPSE_EXPR(NODE)           ACC_CLAUSE_DECL (NODE)
+#define ACC_CLAUSE_IF_EXPR(NODE)                 ACC_CLAUSE_DECL (NODE)
+#define ACC_WAIT_EXPR(NODE)                      ACC_CLAUSE_DECL (NODE)
+
+#define ACC_DATA_BODY(NODE)          TREE_OPERAND (ACC_DATA_CHECK (NODE), 0)
+#define ACC_DATA_CLAUSES(NODE)       TREE_OPERAND (ACC_DATA_CHECK (NODE), 1)
+
+#define ACC_DECLARE_CLAUSES(NODE)       TREE_OPERAND (ACC_DECLARE_CHECK (NODE), 0)
+
+#define ACC_UPDATE_CLAUSES(NODE)       TREE_OPERAND (ACC_UPDATE_CHECK (NODE), 0)
+
+#define ACC_WAIT_CLAUSES(NODE)       TREE_OPERAND (ACC_WAIT_CHECK (NODE), 0)
+
+#define ACC_CACHE_CLAUSES(NODE)       TREE_OPERAND (ACC_CACHE_CHECK (NODE), 0)
+
+#define ACC_HOST_DATA_BODY(NODE)          TREE_OPERAND (ACC_HOST_DATA_CHECK (NODE), 0)
+#define ACC_HOST_DATA_CLAUSES(NODE)       TREE_OPERAND (ACC_HOST_DATA_CHECK (NODE), 1)
+
+#define ACC_CLAUSE_REDUCTION_CODE(NODE) \
+            ((NODE)->acc_clause.subcode.reduction_code)
+#define ACC_CLAUSE_REDUCTION_INIT(NODE) \
+            ((NODE)->acc_clause.ops[1])
+#define ACC_CLAUSE_REDUCTION_MERGE(NODE) \
+            ((NODE)->acc_clause.ops[2])
+#define ACC_CLAUSE_REDUCTION_PLACEHOLDER(NODE) \
+            ((NODE)->acc_clause.ops[3])
+
 /* OpenMP directive and clause accessors.  */
 
 #define OMP_BODY(NODE) \
@@ -3484,6 +3567,9 @@ extern tree build_block (tree, tree, tree, tree);
 extern tree build_empty_stmt (location_t);
 extern tree build_omp_clause (location_t, enum omp_clause_code);
 extern tree find_omp_clause (tree, enum omp_clause_code);
+extern tree build_acc_clause (location_t, enum acc_clause_code);
+extern tree build_acc_subarray_bounds (tree, tree, tree);
+extern tree build_acc_subarray (tree, tree);
 
 extern tree build_vl_exp_stat (enum tree_code, int MEM_STAT_DECL);
 #define build_vl_exp(c,n) build_vl_exp_stat (c,n MEM_STAT_INFO)
diff --git a/gcc/treestruct.def b/gcc/treestruct.def
index 7769615bb42..68d2300974e 100644
--- a/gcc/treestruct.def
+++ b/gcc/treestruct.def
@@ -66,5 +66,6 @@ DEFTREESTRUCT(TS_BINFO, "binfo")
 DEFTREESTRUCT(TS_STATEMENT_LIST, "statement list")
 DEFTREESTRUCT(TS_CONSTRUCTOR, "constructor")
 DEFTREESTRUCT(TS_OMP_CLAUSE, "omp clause")
+DEFTREESTRUCT(TS_ACC_CLAUSE, "acc clause")
 DEFTREESTRUCT(TS_OPTIMIZATION, "optimization options")
 DEFTREESTRUCT(TS_TARGET_OPTION, "target options")
diff --git a/liboacc/Makefile.am b/liboacc/Makefile.am
new file mode 100755
index 00000000000..3f533ebb98f
--- /dev/null
+++ b/liboacc/Makefile.am
@@ -0,0 +1,32 @@
+ACLOCAL_AMFLAGS = -I .. -I ../config
+
+## May be used by toolexeclibdir.
+gcc_version := $(shell cat $(top_srcdir)/../gcc/BASE-VER)
+
+config_path = @config_path@
+search_path = $(addprefix $(top_srcdir)/config/, $(config_path)) $(top_srcdir)
+
+fincludedir = $(libdir)/gcc/$(target_alias)/$(gcc_version)/finclude
+libsubincludedir = $(libdir)/gcc/$(target_alias)/$(gcc_version)/include
+
+vpath % $(strip $(search_path))
+
+AM_CPPFLAGS = $(addprefix -I, $(search_path))
+AM_CFLAGS = $(XCFLAGS)
+AM_LDFLAGS = $(XLDFLAGS) $(SECTION_LDFLAGS) $(OPT_LDFLAGS)
+
+toolexeclib_LTLIBRARIES = liboacc.la
+nodist_toolexeclib_HEADERS = liboacc.spec
+
+liboacc_la_SOURCES = liboacc.h \
+					liboacc-internal.h \
+					openacc.h \
+					liboacc.c \
+					openacc.c \
+					platform.c \
+					runtime.c \
+					program.c \
+					memory.c \
+					synchro.c
+					
+liboacc_la_CPPFLAGS = -I$(openclinc)
diff --git a/liboacc/Makefile.in b/liboacc/Makefile.in
new file mode 100644
index 00000000000..b67f1f2dc06
--- /dev/null
+++ b/liboacc/Makefile.in
@@ -0,0 +1,881 @@
+# Makefile.in generated by automake 1.12.5 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2012 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__make_dryrun = \
+  { \
+    am__dry=no; \
+    case $$MAKEFLAGS in \
+      *\\[\ \	]*) \
+        echo 'am--echo: ; @echo "AM"  OK' | $(MAKE) -f - 2>/dev/null \
+          | grep '^AM OK$$' >/dev/null || am__dry=yes;; \
+      *) \
+        for am__flg in $$MAKEFLAGS; do \
+          case $$am__flg in \
+            *=*|--*) ;; \
+            *n*) am__dry=yes; break;; \
+          esac; \
+        done;; \
+    esac; \
+    test $$am__dry = yes; \
+  }
+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@
+target_triplet = @target@
+subdir = .
+DIST_COMMON = $(am__configure_deps) $(srcdir)/Makefile.am \
+	$(srcdir)/Makefile.in $(srcdir)/config.h.in \
+	$(srcdir)/liboacc.spec.in $(top_srcdir)/../config.guess \
+	$(top_srcdir)/../config.sub $(top_srcdir)/../depcomp \
+	$(top_srcdir)/../install-sh $(top_srcdir)/../ltmain.sh \
+	$(top_srcdir)/../missing $(top_srcdir)/../mkinstalldirs \
+	$(top_srcdir)/configure
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/../config/depstand.m4 \
+	$(top_srcdir)/../config/lead-dot.m4 \
+	$(top_srcdir)/../config/multi.m4 \
+	$(top_srcdir)/../config/override.m4 \
+	$(top_srcdir)/../libtool.m4 $(top_srcdir)/../ltoptions.m4 \
+	$(top_srcdir)/../ltsugar.m4 $(top_srcdir)/../ltversion.m4 \
+	$(top_srcdir)/../lt~obsolete.m4 $(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \
+ configure.lineno config.status.lineno
+mkinstalldirs = $(SHELL) $(top_srcdir)/../mkinstalldirs
+CONFIG_HEADER = config.h
+CONFIG_CLEAN_FILES = liboacc.spec
+CONFIG_CLEAN_VPATH_FILES =
+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__installdirs = "$(DESTDIR)$(toolexeclibdir)" \
+	"$(DESTDIR)$(toolexeclibdir)"
+LTLIBRARIES = $(toolexeclib_LTLIBRARIES)
+liboacc_la_LIBADD =
+am_liboacc_la_OBJECTS = liboacc_la-liboacc.lo liboacc_la-openacc.lo \
+	liboacc_la-platform.lo liboacc_la-runtime.lo \
+	liboacc_la-program.lo liboacc_la-memory.lo \
+	liboacc_la-synchro.lo
+liboacc_la_OBJECTS = $(am_liboacc_la_OBJECTS)
+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) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
+	--mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+CCLD = $(CC)
+LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
+	--mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \
+	$(LDFLAGS) -o $@
+SOURCES = $(liboacc_la_SOURCES)
+DIST_SOURCES = $(liboacc_la_SOURCES)
+am__can_run_installinfo = \
+  case $$AM_UPDATE_INFO_DIR in \
+    n|no|NO) false;; \
+    *) (install-info --version) >/dev/null 2>&1;; \
+  esac
+HEADERS = $(nodist_toolexeclib_HEADERS)
+ETAGS = etags
+CTAGS = ctags
+CSCOPE = cscope
+AM_RECURSIVE_TARGETS = cscope
+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)
+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@
+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@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+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@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+THREADLIBS = @THREADLIBS@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+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@
+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@
+libtool_VERSION = @libtool_VERSION@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+multi_basedir = @multi_basedir@
+oldincludedir = @oldincludedir@
+openclinc = @openclinc@
+opencllib = @opencllib@
+pdfdir = @pdfdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target = @target@
+target_alias = @target_alias@
+target_cpu = @target_cpu@
+target_os = @target_os@
+target_vendor = @target_vendor@
+toolexecdir = @toolexecdir@
+toolexeclibdir = @toolexeclibdir@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+ACLOCAL_AMFLAGS = -I .. -I ../config
+gcc_version := $(shell cat $(top_srcdir)/../gcc/BASE-VER)
+config_path = @config_path@
+search_path = $(addprefix $(top_srcdir)/config/, $(config_path)) $(top_srcdir)
+fincludedir = $(libdir)/gcc/$(target_alias)/$(gcc_version)/finclude
+libsubincludedir = $(libdir)/gcc/$(target_alias)/$(gcc_version)/include
+AM_CPPFLAGS = $(addprefix -I, $(search_path))
+AM_CFLAGS = $(XCFLAGS)
+AM_LDFLAGS = $(XLDFLAGS) $(SECTION_LDFLAGS) $(OPT_LDFLAGS)
+toolexeclib_LTLIBRARIES = liboacc.la
+nodist_toolexeclib_HEADERS = liboacc.spec
+liboacc_la_SOURCES = liboacc.h \
+					liboacc-internal.h \
+					openacc.h \
+					liboacc.c \
+					openacc.c \
+					platform.c \
+					runtime.c \
+					program.c \
+					memory.c \
+					synchro.c
+
+liboacc_la_CPPFLAGS = -I$(openclinc)
+all: config.h
+	$(MAKE) $(AM_MAKEFLAGS) all-am
+
+.SUFFIXES:
+.SUFFIXES: .c .lo .o .obj
+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
+.PRECIOUS: 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):
+
+config.h: stamp-h1
+	@if test ! -f $@; then rm -f stamp-h1; else :; fi
+	@if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) stamp-h1; else :; fi
+
+stamp-h1: $(srcdir)/config.h.in $(top_builddir)/config.status
+	@rm -f stamp-h1
+	cd $(top_builddir) && $(SHELL) ./config.status config.h
+$(srcdir)/config.h.in:  $(am__configure_deps) 
+	($(am__cd) $(top_srcdir) && $(AUTOHEADER))
+	rm -f stamp-h1
+	touch $@
+
+distclean-hdr:
+	-rm -f config.h stamp-h1
+liboacc.spec: $(top_builddir)/config.status $(srcdir)/liboacc.spec.in
+	cd $(top_builddir) && $(SHELL) ./config.status $@
+install-toolexeclibLTLIBRARIES: $(toolexeclib_LTLIBRARIES)
+	@$(NORMAL_INSTALL)
+	@list='$(toolexeclib_LTLIBRARIES)'; test -n "$(toolexeclibdir)" || list=; \
+	list2=; for p in $$list; do \
+	  if test -f $$p; then \
+	    list2="$$list2 $$p"; \
+	  else :; fi; \
+	done; \
+	test -z "$$list2" || { \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(toolexeclibdir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(toolexeclibdir)" || exit 1; \
+	  echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(toolexeclibdir)'"; \
+	  $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(toolexeclibdir)"; \
+	}
+
+uninstall-toolexeclibLTLIBRARIES:
+	@$(NORMAL_UNINSTALL)
+	@list='$(toolexeclib_LTLIBRARIES)'; test -n "$(toolexeclibdir)" || list=; \
+	for p in $$list; do \
+	  $(am__strip_dir) \
+	  echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(toolexeclibdir)/$$f'"; \
+	  $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(toolexeclibdir)/$$f"; \
+	done
+
+clean-toolexeclibLTLIBRARIES:
+	-test -z "$(toolexeclib_LTLIBRARIES)" || rm -f $(toolexeclib_LTLIBRARIES)
+	@list='$(toolexeclib_LTLIBRARIES)'; \
+	locs=`for p in $$list; do echo $$p; done | \
+	      sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+	      sort -u`; \
+	test -z "$$locs" || { \
+	  echo rm -f $${locs}; \
+	  rm -f $${locs}; \
+	}
+liboacc.la: $(liboacc_la_OBJECTS) $(liboacc_la_DEPENDENCIES) $(EXTRA_liboacc_la_DEPENDENCIES) 
+	$(LINK) -rpath $(toolexeclibdir) $(liboacc_la_OBJECTS) $(liboacc_la_LIBADD) $(LIBS)
+
+mostlyclean-compile:
+	-rm -f *.$(OBJEXT)
+
+distclean-compile:
+	-rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/liboacc_la-liboacc.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/liboacc_la-memory.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/liboacc_la-openacc.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/liboacc_la-platform.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/liboacc_la-program.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/liboacc_la-runtime.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/liboacc_la-synchro.Plo@am__quote@
+
+.c.o:
+@am__fastdepCC_TRUE@	$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(COMPILE) -c $<
+
+.c.obj:
+@am__fastdepCC_TRUE@	$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
+@am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(COMPILE) -c `$(CYGPATH_W) '$<'`
+
+.c.lo:
+@am__fastdepCC_TRUE@	$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(LTCOMPILE) -c -o $@ $<
+
+liboacc_la-liboacc.lo: liboacc.c
+@am__fastdepCC_TRUE@	$(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(liboacc_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT liboacc_la-liboacc.lo -MD -MP -MF $(DEPDIR)/liboacc_la-liboacc.Tpo -c -o liboacc_la-liboacc.lo `test -f 'liboacc.c' || echo '$(srcdir)/'`liboacc.c
+@am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/liboacc_la-liboacc.Tpo $(DEPDIR)/liboacc_la-liboacc.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='liboacc.c' object='liboacc_la-liboacc.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(liboacc_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o liboacc_la-liboacc.lo `test -f 'liboacc.c' || echo '$(srcdir)/'`liboacc.c
+
+liboacc_la-openacc.lo: openacc.c
+@am__fastdepCC_TRUE@	$(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(liboacc_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT liboacc_la-openacc.lo -MD -MP -MF $(DEPDIR)/liboacc_la-openacc.Tpo -c -o liboacc_la-openacc.lo `test -f 'openacc.c' || echo '$(srcdir)/'`openacc.c
+@am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/liboacc_la-openacc.Tpo $(DEPDIR)/liboacc_la-openacc.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='openacc.c' object='liboacc_la-openacc.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(liboacc_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o liboacc_la-openacc.lo `test -f 'openacc.c' || echo '$(srcdir)/'`openacc.c
+
+liboacc_la-platform.lo: platform.c
+@am__fastdepCC_TRUE@	$(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(liboacc_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT liboacc_la-platform.lo -MD -MP -MF $(DEPDIR)/liboacc_la-platform.Tpo -c -o liboacc_la-platform.lo `test -f 'platform.c' || echo '$(srcdir)/'`platform.c
+@am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/liboacc_la-platform.Tpo $(DEPDIR)/liboacc_la-platform.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='platform.c' object='liboacc_la-platform.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(liboacc_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o liboacc_la-platform.lo `test -f 'platform.c' || echo '$(srcdir)/'`platform.c
+
+liboacc_la-runtime.lo: runtime.c
+@am__fastdepCC_TRUE@	$(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(liboacc_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT liboacc_la-runtime.lo -MD -MP -MF $(DEPDIR)/liboacc_la-runtime.Tpo -c -o liboacc_la-runtime.lo `test -f 'runtime.c' || echo '$(srcdir)/'`runtime.c
+@am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/liboacc_la-runtime.Tpo $(DEPDIR)/liboacc_la-runtime.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='runtime.c' object='liboacc_la-runtime.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(liboacc_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o liboacc_la-runtime.lo `test -f 'runtime.c' || echo '$(srcdir)/'`runtime.c
+
+liboacc_la-program.lo: program.c
+@am__fastdepCC_TRUE@	$(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(liboacc_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT liboacc_la-program.lo -MD -MP -MF $(DEPDIR)/liboacc_la-program.Tpo -c -o liboacc_la-program.lo `test -f 'program.c' || echo '$(srcdir)/'`program.c
+@am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/liboacc_la-program.Tpo $(DEPDIR)/liboacc_la-program.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='program.c' object='liboacc_la-program.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(liboacc_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o liboacc_la-program.lo `test -f 'program.c' || echo '$(srcdir)/'`program.c
+
+liboacc_la-memory.lo: memory.c
+@am__fastdepCC_TRUE@	$(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(liboacc_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT liboacc_la-memory.lo -MD -MP -MF $(DEPDIR)/liboacc_la-memory.Tpo -c -o liboacc_la-memory.lo `test -f 'memory.c' || echo '$(srcdir)/'`memory.c
+@am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/liboacc_la-memory.Tpo $(DEPDIR)/liboacc_la-memory.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='memory.c' object='liboacc_la-memory.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(liboacc_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o liboacc_la-memory.lo `test -f 'memory.c' || echo '$(srcdir)/'`memory.c
+
+liboacc_la-synchro.lo: synchro.c
+@am__fastdepCC_TRUE@	$(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(liboacc_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT liboacc_la-synchro.lo -MD -MP -MF $(DEPDIR)/liboacc_la-synchro.Tpo -c -o liboacc_la-synchro.lo `test -f 'synchro.c' || echo '$(srcdir)/'`synchro.c
+@am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/liboacc_la-synchro.Tpo $(DEPDIR)/liboacc_la-synchro.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='synchro.c' object='liboacc_la-synchro.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(liboacc_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o liboacc_la-synchro.lo `test -f 'synchro.c' || echo '$(srcdir)/'`synchro.c
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+
+distclean-libtool:
+	-rm -f libtool config.lt
+install-nodist_toolexeclibHEADERS: $(nodist_toolexeclib_HEADERS)
+	@$(NORMAL_INSTALL)
+	@list='$(nodist_toolexeclib_HEADERS)'; test -n "$(toolexeclibdir)" || list=; \
+	if test -n "$$list"; then \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(toolexeclibdir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(toolexeclibdir)" || exit 1; \
+	fi; \
+	for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  echo "$$d$$p"; \
+	done | $(am__base_list) | \
+	while read files; do \
+	  echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(toolexeclibdir)'"; \
+	  $(INSTALL_HEADER) $$files "$(DESTDIR)$(toolexeclibdir)" || exit $$?; \
+	done
+
+uninstall-nodist_toolexeclibHEADERS:
+	@$(NORMAL_UNINSTALL)
+	@list='$(nodist_toolexeclib_HEADERS)'; test -n "$(toolexeclibdir)" || list=; \
+	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
+	dir='$(DESTDIR)$(toolexeclibdir)'; $(am__uninstall_files_from_dir)
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	mkid -fID $$unique
+tags: TAGS
+
+TAGS:  $(HEADERS) $(SOURCES) config.h.in $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	set x; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS) config.h.in $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	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
+CTAGS:  $(HEADERS) $(SOURCES) config.h.in $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	list='$(SOURCES) $(HEADERS) config.h.in $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	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:  $(HEADERS) $(SOURCES) $(LISP)
+	list='$(SOURCES) $(HEADERS) $(LISP)'; \
+	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
+
+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
+	-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
+	tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z
+	$(am__post_remove_distdir)
+
+dist-shar: distdir
+	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)/_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 \
+	  && ../configure --srcdir=.. --prefix="$$dc_install_base" \
+	    $(AM_DISTCHECK_CONFIGURE_FLAGS) \
+	    $(DISTCHECK_CONFIGURE_FLAGS) \
+	  && $(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
+check: check-am
+all-am: Makefile $(LTLIBRARIES) $(HEADERS) config.h
+installdirs:
+	for dir in "$(DESTDIR)$(toolexeclibdir)" "$(DESTDIR)$(toolexeclibdir)"; do \
+	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+	done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+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:
+
+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-am
+
+clean-am: clean-generic clean-libtool clean-toolexeclibLTLIBRARIES \
+	mostlyclean-am
+
+distclean: distclean-am
+	-rm -f $(am__CONFIG_DISTCLEAN_FILES)
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+	distclean-hdr distclean-libtool distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am: install-nodist_toolexeclibHEADERS \
+	install-toolexeclibLTLIBRARIES
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-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-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+	mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-nodist_toolexeclibHEADERS \
+	uninstall-toolexeclibLTLIBRARIES
+
+.MAKE: all install-am install-strip
+
+.PHONY: CTAGS GTAGS all all-am am--refresh check check-am clean \
+	clean-cscope clean-generic clean-libtool \
+	clean-toolexeclibLTLIBRARIES cscope cscopelist ctags dist \
+	dist-all dist-bzip2 dist-gzip dist-lzip dist-shar dist-tarZ \
+	dist-xz dist-zip distcheck distclean distclean-compile \
+	distclean-generic distclean-hdr distclean-libtool \
+	distclean-tags distcleancheck distdir distuninstallcheck dvi \
+	dvi-am html html-am info info-am install install-am \
+	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-nodist_toolexeclibHEADERS install-pdf install-pdf-am \
+	install-ps install-ps-am install-strip \
+	install-toolexeclibLTLIBRARIES installcheck installcheck-am \
+	installdirs maintainer-clean maintainer-clean-generic \
+	mostlyclean mostlyclean-compile mostlyclean-generic \
+	mostlyclean-libtool pdf pdf-am ps ps-am tags uninstall \
+	uninstall-am uninstall-nodist_toolexeclibHEADERS \
+	uninstall-toolexeclibLTLIBRARIES
+
+
+vpath % $(strip $(search_path))
+
+# 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:
diff --git a/liboacc/acinclude.m4 b/liboacc/acinclude.m4
new file mode 100755
index 00000000000..7a937cefe8c
--- /dev/null
+++ b/liboacc/acinclude.m4
@@ -0,0 +1,38 @@
+dnl ----------------------------------------------------------------------
+dnl This whole bit snagged from libstdc++-v3.
+
+dnl
+dnl LIBOACC_ENABLE
+dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING)
+dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, permit a|b|c)
+dnl    (FEATURE, DEFAULT, HELP-ARG, HELP-STRING, SHELL-CODE-HANDLER)
+dnl
+dnl See docs/html/17_intro/configury.html#enable for documentation.
+dnl
+m4_define([LIBOACC_ENABLE],[dnl
+m4_define([_g_switch],[--enable-$1])dnl
+m4_define([_g_help],[AC_HELP_STRING(_g_switch$3,[$4 @<:@default=$2@:>@])])dnl
+ AC_ARG_ENABLE($1,_g_help,
+  m4_bmatch([$5],
+   [^permit ],
+     [[
+      case "$enableval" in
+       m4_bpatsubst([$5],[permit ])) ;;
+       *) AC_MSG_ERROR(Unknown argument to enable/disable $1) ;;
+          dnl Idea for future:  generate a URL pointing to
+          dnl "onlinedocs/configopts.html#whatever"
+      esac
+     ]],
+   [^$],
+     [[
+      case "$enableval" in
+       yes|no) ;;
+       *) AC_MSG_ERROR(Argument to enable/disable $1 must be yes or no) ;;
+      esac
+     ]],
+   [[$5]]),
+  [enable_]m4_bpatsubst([$1],-,_)[=][$2])
+m4_undefine([_g_switch])dnl
+m4_undefine([_g_help])dnl
+])
+ 
diff --git a/liboacc/aclocal.m4 b/liboacc/aclocal.m4
new file mode 100644
index 00000000000..cf48f1e6383
--- /dev/null
+++ b/liboacc/aclocal.m4
@@ -0,0 +1,935 @@
+# generated automatically by aclocal 1.12.5 -*- Autoconf -*-
+
+# Copyright (C) 1996-2012 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_AUTOCONF_VERSION],
+  [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
+m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.64],,
+[m4_warning([this file was generated for autoconf 2.64.
+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'.])])
+
+# Copyright (C) 2002-2012 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.12'
+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.12.5], [],
+      [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.12.5])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-2012 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],
+[dnl Rely on autoconf to set up CDPATH properly.
+AC_PREREQ([2.50])dnl
+# expand $ac_aux_dir to an absolute path
+am_aux_dir=`cd $ac_aux_dir && pwd`
+])
+
+# AM_CONDITIONAL                                            -*- Autoconf -*-
+
+# Copyright (C) 1997-2012 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-2012 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-2012 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],
+[{
+  # Autoconf 2.62 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-2012 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.
+
+# 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.62])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.  For more info, see:
+http://www.gnu.org/software/automake/manual/automake.html#Modernize-AM_INIT_AUTOMAKE-invocation])
+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.  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
+dnl Support for Objective C++ was only introduced in Autoconf 2.65,
+dnl but we still cater to Autoconf 2.62.
+m4_ifdef([AC_PROG_OBJCXX],
+[AC_PROVIDE_IFELSE([AC_PROG_OBJCXX],
+		  [_AM_DEPENDENCIES([OBJCXX])],
+		  [m4_define([AC_PROG_OBJCXX],
+			     m4_defn([AC_PROG_OBJCXX])[_AM_DEPENDENCIES([OBJCXX])])])])dnl
+])
+_AM_IF_OPTION([silent-rules], [AC_REQUIRE([AM_SILENT_RULES])])dnl
+dnl The 'parallel-tests' driver may need to know about EXEEXT, so add the
+dnl 'am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen.  This macro
+dnl 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
+])
+
+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-2012 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}" != 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])])
+
+# Check to see how 'make' treats includes.	            -*- Autoconf -*-
+
+# Copyright (C) 2001-2012 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-2012 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 supports --run.
+# If it does, 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 --run true"; then
+  am_missing_run="$MISSING --run "
+else
+  am_missing_run=
+  AC_MSG_WARN(['missing' script is too old or missing])
+fi
+])
+
+# Helper functions for option handling.                     -*- Autoconf -*-
+
+# Copyright (C) 2001-2012 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])])
+
+# Check to make sure that the build environment is sane.    -*- Autoconf -*-
+
+# Copyright (C) 1996-2012 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) 2001-2012 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-2012 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-2012 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}'])
+m4_if([$1], [v7],
+     [am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'],
+     [m4_case([$1], [ustar],, [pax],,
+              [m4_fatal([Unknown tar format])])
+AC_MSG_CHECKING([how to create a $1 tar archive])
+# Loop over all known methods to create a tar archive until one works.
+_am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none'
+_am_tools=${am_cv_prog_tar_$1-$_am_tools}
+# Do not fold the above two line into one, because Tru64 sh and
+# Solaris sh will not grok spaces in the rhs of '-'.
+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])
+    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([../config/depstand.m4])
+m4_include([../config/lead-dot.m4])
+m4_include([../config/multi.m4])
+m4_include([../config/override.m4])
+m4_include([../libtool.m4])
+m4_include([../ltoptions.m4])
+m4_include([../ltsugar.m4])
+m4_include([../ltversion.m4])
+m4_include([../lt~obsolete.m4])
+m4_include([acinclude.m4])
diff --git a/liboacc/config.h.in b/liboacc/config.h.in
new file mode 100644
index 00000000000..a4883029be2
--- /dev/null
+++ b/liboacc/config.h.in
@@ -0,0 +1,78 @@
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#undef HAVE_DLFCN_H
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#undef HAVE_INTTYPES_H
+
+/* Define to 1 if your system has a GNU libc compatible `malloc' function, and
+   to 0 otherwise. */
+#undef HAVE_MALLOC
+
+/* Define to 1 if you have the <memory.h> header file. */
+#undef HAVE_MEMORY_H
+
+/* Define to 1 if you have the <pthread.h> header file. */
+#undef HAVE_PTHREAD_H
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#undef HAVE_STDINT_H
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#undef HAVE_STDLIB_H
+
+/* Define to 1 if you have the <strings.h> header file. */
+#undef HAVE_STRINGS_H
+
+/* Define to 1 if you have the <string.h> header file. */
+#undef HAVE_STRING_H
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#undef HAVE_SYS_STAT_H
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#undef HAVE_SYS_TYPES_H
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#undef HAVE_UNISTD_H
+
+/* Define to the sub-directory in which libtool stores uninstalled libraries.
+   */
+#undef LT_OBJDIR
+
+/* Define to 1 if your C compiler doesn't accept -c and -o together. */
+#undef NO_MINUS_C_MINUS_O
+
+/* Name of package */
+#undef PACKAGE
+
+/* Define to the address where bug reports for this package should be sent. */
+#undef PACKAGE_BUGREPORT
+
+/* Define to the full name of this package. */
+#undef PACKAGE_NAME
+
+/* Define to the full name and version of this package. */
+#undef PACKAGE_STRING
+
+/* Define to the one symbol short name of this package. */
+#undef PACKAGE_TARNAME
+
+/* Define to the home page for this package. */
+#undef PACKAGE_URL
+
+/* Define to the version of this package. */
+#undef PACKAGE_VERSION
+
+/* Define to 1 if you have the ANSI C header files. */
+#undef STDC_HEADERS
+
+/* Version number of package */
+#undef VERSION
+
+/* Define to rpl_malloc if the replacement function should be used. */
+#undef malloc
+
+/* Define to `unsigned int' if <sys/types.h> does not define. */
+#undef size_t
diff --git a/liboacc/configure b/liboacc/configure
new file mode 100755
index 00000000000..840561804a1
--- /dev/null
+++ b/liboacc/configure
@@ -0,0 +1,13506 @@
+#! /bin/sh
+# Guess values for system-dependent variables and create Makefiles.
+# Generated by GNU Autoconf 2.64 for OpenACC Runtime Library 1.0.
+#
+# Report bugs to <dark_beer@rambler.ru>.
+#
+# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
+# 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software
+# Foundation, Inc.
+#
+# This configure script is free software; the Free Software Foundation
+# gives unlimited permission to copy, distribute and modify it.
+## -------------------- ##
+## M4sh Initialization. ##
+## -------------------- ##
+
+# Be more Bourne compatible
+DUALCASE=1; export DUALCASE # for MKS sh
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+  setopt NO_GLOB_SUBST
+else
+  case `(set -o) 2>/dev/null` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+
+
+as_nl='
+'
+export as_nl
+# Printing a long string crashes Solaris 7 /usr/bin/printf.
+as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
+# Prefer a ksh shell builtin over an external printf program on Solaris,
+# but without wasting forks for bash or zsh.
+if test -z "$BASH_VERSION$ZSH_VERSION" \
+    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='print -r --'
+  as_echo_n='print -rn --'
+elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='printf %s\n'
+  as_echo_n='printf %s'
+else
+  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
+    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
+    as_echo_n='/usr/ucb/echo -n'
+  else
+    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
+    as_echo_n_body='eval
+      arg=$1;
+      case $arg in #(
+      *"$as_nl"*)
+	expr "X$arg" : "X\\(.*\\)$as_nl";
+	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
+      esac;
+      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
+    '
+    export as_echo_n_body
+    as_echo_n='sh -c $as_echo_n_body as_echo'
+  fi
+  export as_echo_body
+  as_echo='sh -c $as_echo_body as_echo'
+fi
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  PATH_SEPARATOR=:
+  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
+    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
+      PATH_SEPARATOR=';'
+  }
+fi
+
+
+# IFS
+# We need space, tab and new line, in precisely that order.  Quoting is
+# there to prevent editors from complaining about space-tab.
+# (If _AS_PATH_WALK were called with IFS unset, it would disable word
+# splitting by setting IFS to empty value.)
+IFS=" ""	$as_nl"
+
+# Find who we are.  Look in the path if we contain no directory separator.
+case $0 in #((
+  *[\\/]* ) as_myself=$0 ;;
+  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+  done
+IFS=$as_save_IFS
+
+     ;;
+esac
+# We did not find ourselves, most probably we were run as `sh COMMAND'
+# in which case we are not to be found in the path.
+if test "x$as_myself" = x; then
+  as_myself=$0
+fi
+if test ! -f "$as_myself"; then
+  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+  exit 1
+fi
+
+# Unset variables that we do not need and which cause bugs (e.g. in
+# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
+# suppresses any "Segmentation fault" message there.  '((' could
+# trigger a bug in pdksh 5.2.14.
+for as_var in BASH_ENV ENV MAIL MAILPATH
+do eval test x\${$as_var+set} = xset \
+  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
+done
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# NLS nuisances.
+LC_ALL=C
+export LC_ALL
+LANGUAGE=C
+export LANGUAGE
+
+# CDPATH.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+if test "x$CONFIG_SHELL" = x; then
+  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '\${1+\"\$@\"}'='\"\$@\"'
+  setopt NO_GLOB_SUBST
+else
+  case \`(set -o) 2>/dev/null\` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+"
+  as_required="as_fn_return () { (exit \$1); }
+as_fn_success () { as_fn_return 0; }
+as_fn_failure () { as_fn_return 1; }
+as_fn_ret_success () { return 0; }
+as_fn_ret_failure () { return 1; }
+
+exitcode=0
+as_fn_success || { exitcode=1; echo as_fn_success failed.; }
+as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
+as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
+as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
+if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
+
+else
+  exitcode=1; echo positional parameters were not saved.
+fi
+test x\$exitcode = x0 || exit 1"
+  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
+  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
+  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
+  test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
+
+  test -n \"\${ZSH_VERSION+set}\${BASH_VERSION+set}\" || (
+    ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+    ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO
+    ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO
+    PATH=/empty FPATH=/empty; export PATH FPATH
+    test \"X\`printf %s \$ECHO\`\" = \"X\$ECHO\" \\
+      || test \"X\`print -r -- \$ECHO\`\" = \"X\$ECHO\" ) || exit 1
+test \$(( 1 + 1 )) = 2 || exit 1"
+  if (eval "$as_required") 2>/dev/null; then :
+  as_have_required=yes
+else
+  as_have_required=no
+fi
+  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
+
+else
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+as_found=false
+for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  as_found=:
+  case $as_dir in #(
+	 /*)
+	   for as_base in sh bash ksh sh5; do
+	     # Try only shells that exist, to save several forks.
+	     as_shell=$as_dir/$as_base
+	     if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
+		    { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
+  CONFIG_SHELL=$as_shell as_have_required=yes
+		   if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
+  break 2
+fi
+fi
+	   done;;
+       esac
+  as_found=false
+done
+$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
+	      { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
+  CONFIG_SHELL=$SHELL as_have_required=yes
+fi; }
+IFS=$as_save_IFS
+
+
+      if test "x$CONFIG_SHELL" != x; then :
+  # We cannot yet assume a decent shell, so we have to provide a
+	# neutralization value for shells without unset; and this also
+	# works around shells that cannot unset nonexistent variables.
+	BASH_ENV=/dev/null
+	ENV=/dev/null
+	(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
+	export CONFIG_SHELL
+	exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"}
+fi
+
+    if test x$as_have_required = xno; then :
+  $as_echo "$0: This script requires a shell more modern than all"
+  $as_echo "$0: the shells that I found on your system."
+  if test x${ZSH_VERSION+set} = xset ; then
+    $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
+    $as_echo "$0: be upgraded to zsh 4.3.4 or later."
+  else
+    $as_echo "$0: Please tell bug-autoconf@gnu.org and
+$0: dark_beer@rambler.ru about your system, including any
+$0: error possibly output before this message. Then install
+$0: a modern shell, or manually run the script under such a
+$0: shell if you do have one."
+  fi
+  exit 1
+fi
+fi
+fi
+SHELL=${CONFIG_SHELL-/bin/sh}
+export SHELL
+# Unset more variables known to interfere with behavior of common tools.
+CLICOLOR_FORCE= GREP_OPTIONS=
+unset CLICOLOR_FORCE GREP_OPTIONS
+
+## --------------------- ##
+## M4sh Shell Functions. ##
+## --------------------- ##
+# as_fn_unset VAR
+# ---------------
+# Portably unset VAR.
+as_fn_unset ()
+{
+  { eval $1=; unset $1;}
+}
+as_unset=as_fn_unset
+
+# as_fn_set_status STATUS
+# -----------------------
+# Set $? to STATUS, without forking.
+as_fn_set_status ()
+{
+  return $1
+} # as_fn_set_status
+
+# as_fn_exit STATUS
+# -----------------
+# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
+as_fn_exit ()
+{
+  set +e
+  as_fn_set_status $1
+  exit $1
+} # as_fn_exit
+
+# as_fn_mkdir_p
+# -------------
+# Create "$as_dir" as a directory, including parents if necessary.
+as_fn_mkdir_p ()
+{
+
+  case $as_dir in #(
+  -*) as_dir=./$as_dir;;
+  esac
+  test -d "$as_dir" || eval $as_mkdir_p || {
+    as_dirs=
+    while :; do
+      case $as_dir in #(
+      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
+      *) as_qdir=$as_dir;;
+      esac
+      as_dirs="'$as_qdir' $as_dirs"
+      as_dir=`$as_dirname -- "$as_dir" ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_dir" : 'X\(//\)[^/]' \| \
+	 X"$as_dir" : 'X\(//\)$' \| \
+	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$as_dir" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+      test -d "$as_dir" && break
+    done
+    test -z "$as_dirs" || eval "mkdir $as_dirs"
+  } || test -d "$as_dir" || as_fn_error "cannot create directory $as_dir"
+
+
+} # as_fn_mkdir_p
+# as_fn_append VAR VALUE
+# ----------------------
+# Append the text in VALUE to the end of the definition contained in VAR. Take
+# advantage of any shell optimizations that allow amortized linear growth over
+# repeated appends, instead of the typical quadratic growth present in naive
+# implementations.
+if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
+  eval 'as_fn_append ()
+  {
+    eval $1+=\$2
+  }'
+else
+  as_fn_append ()
+  {
+    eval $1=\$$1\$2
+  }
+fi # as_fn_append
+
+# as_fn_arith ARG...
+# ------------------
+# Perform arithmetic evaluation on the ARGs, and store the result in the
+# global $as_val. Take advantage of shells that can avoid forks. The arguments
+# must be portable across $(()) and expr.
+if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
+  eval 'as_fn_arith ()
+  {
+    as_val=$(( $* ))
+  }'
+else
+  as_fn_arith ()
+  {
+    as_val=`expr "$@" || test $? -eq 1`
+  }
+fi # as_fn_arith
+
+
+# as_fn_error ERROR [LINENO LOG_FD]
+# ---------------------------------
+# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
+# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
+# script with status $?, using 1 if that was 0.
+as_fn_error ()
+{
+  as_status=$?; test $as_status -eq 0 && as_status=1
+  if test "$3"; then
+    as_lineno=${as_lineno-"$2"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+    $as_echo "$as_me:${as_lineno-$LINENO}: error: $1" >&$3
+  fi
+  $as_echo "$as_me: error: $1" >&2
+  as_fn_exit $as_status
+} # as_fn_error
+
+if expr a : '\(a\)' >/dev/null 2>&1 &&
+   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+  as_basename=basename
+else
+  as_basename=false
+fi
+
+if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
+  as_dirname=dirname
+else
+  as_dirname=false
+fi
+
+as_me=`$as_basename -- "$0" ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+
+  as_lineno_1=$LINENO as_lineno_1a=$LINENO
+  as_lineno_2=$LINENO as_lineno_2a=$LINENO
+  eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
+  test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
+  # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
+  sed -n '
+    p
+    /[$]LINENO/=
+  ' <$as_myself |
+    sed '
+      s/[$]LINENO.*/&-/
+      t lineno
+      b
+      :lineno
+      N
+      :loop
+      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
+      t loop
+      s/-\n.*//
+    ' >$as_me.lineno &&
+  chmod +x "$as_me.lineno" ||
+    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
+
+  # Don't try to exec as it changes $[0], causing all sort of problems
+  # (the dirname of $[0] is not the place where we might find the
+  # original and so on.  Autoconf is especially sensitive to this).
+  . "./$as_me.lineno"
+  # Exit status is that of the last command.
+  exit
+}
+
+ECHO_C= ECHO_N= ECHO_T=
+case `echo -n x` in #(((((
+-n*)
+  case `echo 'xy\c'` in
+  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
+  xy)  ECHO_C='\c';;
+  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
+       ECHO_T='	';;
+  esac;;
+*)
+  ECHO_N='-n';;
+esac
+
+rm -f conf$$ conf$$.exe conf$$.file
+if test -d conf$$.dir; then
+  rm -f conf$$.dir/conf$$.file
+else
+  rm -f conf$$.dir
+  mkdir conf$$.dir 2>/dev/null
+fi
+if (echo >conf$$.file) 2>/dev/null; then
+  if ln -s conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s='ln -s'
+    # ... but there are two gotchas:
+    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
+    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
+    # In both cases, we have to default to `cp -p'.
+    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+      as_ln_s='cp -p'
+  elif ln conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s=ln
+  else
+    as_ln_s='cp -p'
+  fi
+else
+  as_ln_s='cp -p'
+fi
+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
+rmdir conf$$.dir 2>/dev/null
+
+if mkdir -p . 2>/dev/null; then
+  as_mkdir_p='mkdir -p "$as_dir"'
+else
+  test -d ./-p && rmdir ./-p
+  as_mkdir_p=false
+fi
+
+if test -x / >/dev/null 2>&1; then
+  as_test_x='test -x'
+else
+  if ls -dL / >/dev/null 2>&1; then
+    as_ls_L_option=L
+  else
+    as_ls_L_option=
+  fi
+  as_test_x='
+    eval sh -c '\''
+      if test -d "$1"; then
+	test -d "$1/.";
+      else
+	case $1 in #(
+	-*)set "./$1";;
+	esac;
+	case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
+	???[sx]*):;;*)false;;esac;fi
+    '\'' sh
+  '
+fi
+as_executable_p=$as_test_x
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+
+SHELL=${CONFIG_SHELL-/bin/sh}
+
+
+exec 7<&0 </dev/null 6>&1
+
+# Name of the host.
+# hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
+# so uname gets run too.
+ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
+
+#
+# Initializations.
+#
+ac_default_prefix=/usr/local
+ac_clean_files=
+ac_config_libobj_dir=.
+LIBOBJS=
+cross_compiling=no
+subdirs=
+MFLAGS=
+MAKEFLAGS=
+
+# Identity of this package.
+PACKAGE_NAME='OpenACC Runtime Library'
+PACKAGE_TARNAME='openacc-runtime-library'
+PACKAGE_VERSION='1.0'
+PACKAGE_STRING='OpenACC Runtime Library 1.0'
+PACKAGE_BUGREPORT='dark_beer@rambler.ru'
+PACKAGE_URL=''
+
+ac_unique_file="liboacc.c"
+# Factoring default headers for most tests.
+ac_includes_default="\
+#include <stdio.h>
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+#ifdef STDC_HEADERS
+# include <stdlib.h>
+# include <stddef.h>
+#else
+# ifdef HAVE_STDLIB_H
+#  include <stdlib.h>
+# endif
+#endif
+#ifdef HAVE_STRING_H
+# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
+#  include <memory.h>
+# endif
+# include <string.h>
+#endif
+#ifdef HAVE_STRINGS_H
+# include <strings.h>
+#endif
+#ifdef HAVE_INTTYPES_H
+# include <inttypes.h>
+#endif
+#ifdef HAVE_STDINT_H
+# include <stdint.h>
+#endif
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif"
+
+ac_subst_vars='am__EXEEXT_FALSE
+am__EXEEXT_TRUE
+LTLIBOBJS
+LIBOBJS
+libtool_VERSION
+CPP
+OTOOL64
+OTOOL
+LIPO
+NMEDIT
+DSYMUTIL
+RANLIB
+AR
+OBJDUMP
+LN_S
+NM
+ac_ct_DUMPBIN
+DUMPBIN
+LD
+FGREP
+EGREP
+GREP
+SED
+LIBTOOL
+am__fastdepCC_FALSE
+am__fastdepCC_TRUE
+CCDEPMODE
+am__nodep
+AMDEPBACKSLASH
+AMDEP_FALSE
+AMDEP_TRUE
+am__quote
+am__include
+DEPDIR
+OBJEXT
+EXEEXT
+ac_ct_CC
+CPPFLAGS
+LDFLAGS
+CFLAGS
+CC
+THREADLIBS
+opencllib
+openclinc
+toolexeclibdir
+toolexecdir
+multi_basedir
+am__untar
+am__tar
+AMTAR
+am__leading_dot
+SET_MAKE
+AWK
+mkdir_p
+MKDIR_P
+INSTALL_STRIP_PROGRAM
+STRIP
+install_sh
+MAKEINFO
+AUTOHEADER
+AUTOMAKE
+AUTOCONF
+ACLOCAL
+VERSION
+PACKAGE
+CYGPATH_W
+am__isrc
+INSTALL_DATA
+INSTALL_SCRIPT
+INSTALL_PROGRAM
+target_os
+target_vendor
+target_cpu
+target
+host_os
+host_vendor
+host_cpu
+host
+build_os
+build_vendor
+build_cpu
+build
+GENINSRC_FALSE
+GENINSRC_TRUE
+target_alias
+host_alias
+build_alias
+LIBS
+ECHO_T
+ECHO_N
+ECHO_C
+DEFS
+mandir
+localedir
+libdir
+psdir
+pdfdir
+dvidir
+htmldir
+infodir
+docdir
+oldincludedir
+includedir
+localstatedir
+sharedstatedir
+sysconfdir
+datadir
+datarootdir
+libexecdir
+sbindir
+bindir
+program_transform_name
+prefix
+exec_prefix
+PACKAGE_URL
+PACKAGE_BUGREPORT
+PACKAGE_STRING
+PACKAGE_VERSION
+PACKAGE_TARNAME
+PACKAGE_NAME
+PATH_SEPARATOR
+SHELL'
+ac_subst_files=''
+ac_user_opts='
+enable_option_checking
+enable_version_specific_runtime_libs
+enable_generated_files_in_srcdir
+enable_multilib
+with_opencl
+with_opencl_include
+with_opencl_lib
+enable_dependency_tracking
+enable_shared
+enable_static
+with_pic
+enable_fast_install
+with_gnu_ld
+enable_libtool_lock
+'
+      ac_precious_vars='build_alias
+host_alias
+target_alias
+CC
+CFLAGS
+LDFLAGS
+LIBS
+CPPFLAGS
+CPP'
+
+
+# Initialize some variables set by options.
+ac_init_help=
+ac_init_version=false
+ac_unrecognized_opts=
+ac_unrecognized_sep=
+# The variables have the same names as the options, with
+# dashes changed to underlines.
+cache_file=/dev/null
+exec_prefix=NONE
+no_create=
+no_recursion=
+prefix=NONE
+program_prefix=NONE
+program_suffix=NONE
+program_transform_name=s,x,x,
+silent=
+site=
+srcdir=
+verbose=
+x_includes=NONE
+x_libraries=NONE
+
+# Installation directory options.
+# These are left unexpanded so users can "make install exec_prefix=/foo"
+# and all the variables that are supposed to be based on exec_prefix
+# by default will actually change.
+# Use braces instead of parens because sh, perl, etc. also accept them.
+# (The list follows the same order as the GNU Coding Standards.)
+bindir='${exec_prefix}/bin'
+sbindir='${exec_prefix}/sbin'
+libexecdir='${exec_prefix}/libexec'
+datarootdir='${prefix}/share'
+datadir='${datarootdir}'
+sysconfdir='${prefix}/etc'
+sharedstatedir='${prefix}/com'
+localstatedir='${prefix}/var'
+includedir='${prefix}/include'
+oldincludedir='/usr/include'
+docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
+infodir='${datarootdir}/info'
+htmldir='${docdir}'
+dvidir='${docdir}'
+pdfdir='${docdir}'
+psdir='${docdir}'
+libdir='${exec_prefix}/lib'
+localedir='${datarootdir}/locale'
+mandir='${datarootdir}/man'
+
+ac_prev=
+ac_dashdash=
+for ac_option
+do
+  # If the previous option needs an argument, assign it.
+  if test -n "$ac_prev"; then
+    eval $ac_prev=\$ac_option
+    ac_prev=
+    continue
+  fi
+
+  case $ac_option in
+  *=*)	ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
+  *)	ac_optarg=yes ;;
+  esac
+
+  # Accept the important Cygnus configure options, so we can diagnose typos.
+
+  case $ac_dashdash$ac_option in
+  --)
+    ac_dashdash=yes ;;
+
+  -bindir | --bindir | --bindi | --bind | --bin | --bi)
+    ac_prev=bindir ;;
+  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
+    bindir=$ac_optarg ;;
+
+  -build | --build | --buil | --bui | --bu)
+    ac_prev=build_alias ;;
+  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
+    build_alias=$ac_optarg ;;
+
+  -cache-file | --cache-file | --cache-fil | --cache-fi \
+  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
+    ac_prev=cache_file ;;
+  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
+  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
+    cache_file=$ac_optarg ;;
+
+  --config-cache | -C)
+    cache_file=config.cache ;;
+
+  -datadir | --datadir | --datadi | --datad)
+    ac_prev=datadir ;;
+  -datadir=* | --datadir=* | --datadi=* | --datad=*)
+    datadir=$ac_optarg ;;
+
+  -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
+  | --dataroo | --dataro | --datar)
+    ac_prev=datarootdir ;;
+  -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
+  | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
+    datarootdir=$ac_optarg ;;
+
+  -disable-* | --disable-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error "invalid feature name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"enable_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval enable_$ac_useropt=no ;;
+
+  -docdir | --docdir | --docdi | --doc | --do)
+    ac_prev=docdir ;;
+  -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
+    docdir=$ac_optarg ;;
+
+  -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
+    ac_prev=dvidir ;;
+  -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
+    dvidir=$ac_optarg ;;
+
+  -enable-* | --enable-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error "invalid feature name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"enable_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval enable_$ac_useropt=\$ac_optarg ;;
+
+  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
+  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
+  | --exec | --exe | --ex)
+    ac_prev=exec_prefix ;;
+  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
+  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
+  | --exec=* | --exe=* | --ex=*)
+    exec_prefix=$ac_optarg ;;
+
+  -gas | --gas | --ga | --g)
+    # Obsolete; use --with-gas.
+    with_gas=yes ;;
+
+  -help | --help | --hel | --he | -h)
+    ac_init_help=long ;;
+  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
+    ac_init_help=recursive ;;
+  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
+    ac_init_help=short ;;
+
+  -host | --host | --hos | --ho)
+    ac_prev=host_alias ;;
+  -host=* | --host=* | --hos=* | --ho=*)
+    host_alias=$ac_optarg ;;
+
+  -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
+    ac_prev=htmldir ;;
+  -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
+  | --ht=*)
+    htmldir=$ac_optarg ;;
+
+  -includedir | --includedir | --includedi | --included | --include \
+  | --includ | --inclu | --incl | --inc)
+    ac_prev=includedir ;;
+  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
+  | --includ=* | --inclu=* | --incl=* | --inc=*)
+    includedir=$ac_optarg ;;
+
+  -infodir | --infodir | --infodi | --infod | --info | --inf)
+    ac_prev=infodir ;;
+  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
+    infodir=$ac_optarg ;;
+
+  -libdir | --libdir | --libdi | --libd)
+    ac_prev=libdir ;;
+  -libdir=* | --libdir=* | --libdi=* | --libd=*)
+    libdir=$ac_optarg ;;
+
+  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
+  | --libexe | --libex | --libe)
+    ac_prev=libexecdir ;;
+  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
+  | --libexe=* | --libex=* | --libe=*)
+    libexecdir=$ac_optarg ;;
+
+  -localedir | --localedir | --localedi | --localed | --locale)
+    ac_prev=localedir ;;
+  -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
+    localedir=$ac_optarg ;;
+
+  -localstatedir | --localstatedir | --localstatedi | --localstated \
+  | --localstate | --localstat | --localsta | --localst | --locals)
+    ac_prev=localstatedir ;;
+  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
+  | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
+    localstatedir=$ac_optarg ;;
+
+  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
+    ac_prev=mandir ;;
+  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
+    mandir=$ac_optarg ;;
+
+  -nfp | --nfp | --nf)
+    # Obsolete; use --without-fp.
+    with_fp=no ;;
+
+  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
+  | --no-cr | --no-c | -n)
+    no_create=yes ;;
+
+  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
+  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
+    no_recursion=yes ;;
+
+  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
+  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
+  | --oldin | --oldi | --old | --ol | --o)
+    ac_prev=oldincludedir ;;
+  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
+  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
+  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
+    oldincludedir=$ac_optarg ;;
+
+  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
+    ac_prev=prefix ;;
+  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
+    prefix=$ac_optarg ;;
+
+  -program-prefix | --program-prefix | --program-prefi | --program-pref \
+  | --program-pre | --program-pr | --program-p)
+    ac_prev=program_prefix ;;
+  -program-prefix=* | --program-prefix=* | --program-prefi=* \
+  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
+    program_prefix=$ac_optarg ;;
+
+  -program-suffix | --program-suffix | --program-suffi | --program-suff \
+  | --program-suf | --program-su | --program-s)
+    ac_prev=program_suffix ;;
+  -program-suffix=* | --program-suffix=* | --program-suffi=* \
+  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
+    program_suffix=$ac_optarg ;;
+
+  -program-transform-name | --program-transform-name \
+  | --program-transform-nam | --program-transform-na \
+  | --program-transform-n | --program-transform- \
+  | --program-transform | --program-transfor \
+  | --program-transfo | --program-transf \
+  | --program-trans | --program-tran \
+  | --progr-tra | --program-tr | --program-t)
+    ac_prev=program_transform_name ;;
+  -program-transform-name=* | --program-transform-name=* \
+  | --program-transform-nam=* | --program-transform-na=* \
+  | --program-transform-n=* | --program-transform-=* \
+  | --program-transform=* | --program-transfor=* \
+  | --program-transfo=* | --program-transf=* \
+  | --program-trans=* | --program-tran=* \
+  | --progr-tra=* | --program-tr=* | --program-t=*)
+    program_transform_name=$ac_optarg ;;
+
+  -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
+    ac_prev=pdfdir ;;
+  -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
+    pdfdir=$ac_optarg ;;
+
+  -psdir | --psdir | --psdi | --psd | --ps)
+    ac_prev=psdir ;;
+  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
+    psdir=$ac_optarg ;;
+
+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+  | -silent | --silent | --silen | --sile | --sil)
+    silent=yes ;;
+
+  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
+    ac_prev=sbindir ;;
+  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
+  | --sbi=* | --sb=*)
+    sbindir=$ac_optarg ;;
+
+  -sharedstatedir | --sharedstatedir | --sharedstatedi \
+  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
+  | --sharedst | --shareds | --shared | --share | --shar \
+  | --sha | --sh)
+    ac_prev=sharedstatedir ;;
+  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
+  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
+  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
+  | --sha=* | --sh=*)
+    sharedstatedir=$ac_optarg ;;
+
+  -site | --site | --sit)
+    ac_prev=site ;;
+  -site=* | --site=* | --sit=*)
+    site=$ac_optarg ;;
+
+  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
+    ac_prev=srcdir ;;
+  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
+    srcdir=$ac_optarg ;;
+
+  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
+  | --syscon | --sysco | --sysc | --sys | --sy)
+    ac_prev=sysconfdir ;;
+  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
+  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
+    sysconfdir=$ac_optarg ;;
+
+  -target | --target | --targe | --targ | --tar | --ta | --t)
+    ac_prev=target_alias ;;
+  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
+    target_alias=$ac_optarg ;;
+
+  -v | -verbose | --verbose | --verbos | --verbo | --verb)
+    verbose=yes ;;
+
+  -version | --version | --versio | --versi | --vers | -V)
+    ac_init_version=: ;;
+
+  -with-* | --with-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error "invalid package name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"with_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval with_$ac_useropt=\$ac_optarg ;;
+
+  -without-* | --without-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+      as_fn_error "invalid package name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+    case $ac_user_opts in
+      *"
+"with_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval with_$ac_useropt=no ;;
+
+  --x)
+    # Obsolete; use --with-x.
+    with_x=yes ;;
+
+  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
+  | --x-incl | --x-inc | --x-in | --x-i)
+    ac_prev=x_includes ;;
+  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
+  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
+    x_includes=$ac_optarg ;;
+
+  -x-libraries | --x-libraries | --x-librarie | --x-librari \
+  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
+    ac_prev=x_libraries ;;
+  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
+  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
+    x_libraries=$ac_optarg ;;
+
+  -*) as_fn_error "unrecognized option: \`$ac_option'
+Try \`$0 --help' for more information."
+    ;;
+
+  *=*)
+    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
+    # Reject names that are not valid shell variable names.
+    case $ac_envvar in #(
+      '' | [0-9]* | *[!_$as_cr_alnum]* )
+      as_fn_error "invalid variable name: \`$ac_envvar'" ;;
+    esac
+    eval $ac_envvar=\$ac_optarg
+    export $ac_envvar ;;
+
+  *)
+    # FIXME: should be removed in autoconf 3.0.
+    $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
+    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+      $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
+    : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
+    ;;
+
+  esac
+done
+
+if test -n "$ac_prev"; then
+  ac_option=--`echo $ac_prev | sed 's/_/-/g'`
+  as_fn_error "missing argument to $ac_option"
+fi
+
+if test -n "$ac_unrecognized_opts"; then
+  case $enable_option_checking in
+    no) ;;
+    fatal) as_fn_error "unrecognized options: $ac_unrecognized_opts" ;;
+    *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
+  esac
+fi
+
+# Check all directory arguments for consistency.
+for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
+		datadir sysconfdir sharedstatedir localstatedir includedir \
+		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
+		libdir localedir mandir
+do
+  eval ac_val=\$$ac_var
+  # Remove trailing slashes.
+  case $ac_val in
+    */ )
+      ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
+      eval $ac_var=\$ac_val;;
+  esac
+  # Be sure to have absolute directory names.
+  case $ac_val in
+    [\\/$]* | ?:[\\/]* )  continue;;
+    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
+  esac
+  as_fn_error "expected an absolute directory name for --$ac_var: $ac_val"
+done
+
+# There might be people who depend on the old broken behavior: `$host'
+# used to hold the argument of --host etc.
+# FIXME: To remove some day.
+build=$build_alias
+host=$host_alias
+target=$target_alias
+
+# FIXME: To remove some day.
+if test "x$host_alias" != x; then
+  if test "x$build_alias" = x; then
+    cross_compiling=maybe
+    $as_echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
+    If a cross compiler is detected then cross compile mode will be used." >&2
+  elif test "x$build_alias" != "x$host_alias"; then
+    cross_compiling=yes
+  fi
+fi
+
+ac_tool_prefix=
+test -n "$host_alias" && ac_tool_prefix=$host_alias-
+
+test "$silent" = yes && exec 6>/dev/null
+
+
+ac_pwd=`pwd` && test -n "$ac_pwd" &&
+ac_ls_di=`ls -di .` &&
+ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
+  as_fn_error "working directory cannot be determined"
+test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
+  as_fn_error "pwd does not report name of working directory"
+
+
+# Find the source files, if location was not specified.
+if test -z "$srcdir"; then
+  ac_srcdir_defaulted=yes
+  # Try the directory containing this script, then the parent directory.
+  ac_confdir=`$as_dirname -- "$as_myself" ||
+$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_myself" : 'X\(//\)[^/]' \| \
+	 X"$as_myself" : 'X\(//\)$' \| \
+	 X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$as_myself" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+  srcdir=$ac_confdir
+  if test ! -r "$srcdir/$ac_unique_file"; then
+    srcdir=..
+  fi
+else
+  ac_srcdir_defaulted=no
+fi
+if test ! -r "$srcdir/$ac_unique_file"; then
+  test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
+  as_fn_error "cannot find sources ($ac_unique_file) in $srcdir"
+fi
+ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
+ac_abs_confdir=`(
+	cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error "$ac_msg"
+	pwd)`
+# When building in place, set srcdir=.
+if test "$ac_abs_confdir" = "$ac_pwd"; then
+  srcdir=.
+fi
+# Remove unnecessary trailing slashes from srcdir.
+# Double slashes in file names in object file debugging info
+# mess up M-x gdb in Emacs.
+case $srcdir in
+*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
+esac
+for ac_var in $ac_precious_vars; do
+  eval ac_env_${ac_var}_set=\${${ac_var}+set}
+  eval ac_env_${ac_var}_value=\$${ac_var}
+  eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
+  eval ac_cv_env_${ac_var}_value=\$${ac_var}
+done
+
+#
+# Report the --help message.
+#
+if test "$ac_init_help" = "long"; then
+  # Omit some internal or obsolete options to make the list less imposing.
+  # This message is too long to be a string in the A/UX 3.1 sh.
+  cat <<_ACEOF
+\`configure' configures OpenACC Runtime Library 1.0 to adapt to many kinds of systems.
+
+Usage: $0 [OPTION]... [VAR=VALUE]...
+
+To assign environment variables (e.g., CC, CFLAGS...), specify them as
+VAR=VALUE.  See below for descriptions of some of the useful variables.
+
+Defaults for the options are specified in brackets.
+
+Configuration:
+  -h, --help              display this help and exit
+      --help=short        display options specific to this package
+      --help=recursive    display the short help of all the included packages
+  -V, --version           display version information and exit
+  -q, --quiet, --silent   do not print \`checking...' messages
+      --cache-file=FILE   cache test results in FILE [disabled]
+  -C, --config-cache      alias for \`--cache-file=config.cache'
+  -n, --no-create         do not create output files
+      --srcdir=DIR        find the sources in DIR [configure dir or \`..']
+
+Installation directories:
+  --prefix=PREFIX         install architecture-independent files in PREFIX
+                          [$ac_default_prefix]
+  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
+                          [PREFIX]
+
+By default, \`make install' will install all the files in
+\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
+an installation prefix other than \`$ac_default_prefix' using \`--prefix',
+for instance \`--prefix=\$HOME'.
+
+For better control, use the options below.
+
+Fine tuning of the installation directories:
+  --bindir=DIR            user executables [EPREFIX/bin]
+  --sbindir=DIR           system admin executables [EPREFIX/sbin]
+  --libexecdir=DIR        program executables [EPREFIX/libexec]
+  --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
+  --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
+  --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
+  --libdir=DIR            object code libraries [EPREFIX/lib]
+  --includedir=DIR        C header files [PREFIX/include]
+  --oldincludedir=DIR     C header files for non-gcc [/usr/include]
+  --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
+  --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
+  --infodir=DIR           info documentation [DATAROOTDIR/info]
+  --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
+  --mandir=DIR            man documentation [DATAROOTDIR/man]
+  --docdir=DIR            documentation root
+                          [DATAROOTDIR/doc/openacc-runtime-library]
+  --htmldir=DIR           html documentation [DOCDIR]
+  --dvidir=DIR            dvi documentation [DOCDIR]
+  --pdfdir=DIR            pdf documentation [DOCDIR]
+  --psdir=DIR             ps documentation [DOCDIR]
+_ACEOF
+
+  cat <<\_ACEOF
+
+Program names:
+  --program-prefix=PREFIX            prepend PREFIX to installed program names
+  --program-suffix=SUFFIX            append SUFFIX to installed program names
+  --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
+
+System types:
+  --build=BUILD     configure for building on BUILD [guessed]
+  --host=HOST       cross-compile to build programs to run on HOST [BUILD]
+  --target=TARGET   configure for building compilers for TARGET [HOST]
+_ACEOF
+fi
+
+if test -n "$ac_init_help"; then
+  case $ac_init_help in
+     short | recursive ) echo "Configuration of OpenACC Runtime Library 1.0:";;
+   esac
+  cat <<\_ACEOF
+
+Optional Features:
+  --disable-option-checking  ignore unrecognized --enable/--with options
+  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
+  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
+  --enable-version-specific-runtime-libs
+                          Specify that runtime libraries should be installed
+                          in a compiler-specific directory [default=no]
+  --enable-generated-files-in-srcdir
+                          put copies of generated files in source dir intended
+                          for creating source tarballs for users without
+                          texinfo bison or flex. [default=no]
+  --enable-multilib       build many library versions (default)
+  --enable-dependency-tracking
+                          do not reject slow dependency extractors
+  --disable-dependency-tracking
+                          speeds up one-time build
+  --enable-shared[=PKGS]  build shared libraries [default=yes]
+  --enable-static[=PKGS]  build static libraries [default=yes]
+  --enable-fast-install[=PKGS]
+                          optimize for fast installation [default=yes]
+  --disable-libtool-lock  avoid locking (might break parallel builds)
+
+Optional Packages:
+  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
+  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
+  --with-opencl=PATH      specify prefix directory for installed OpenCL SDK.
+  --with-opencl-include=PATH
+                          specify directory for installed OpenCL SDK include
+                          files
+  --with-opencl-lib=PATH  specify directory for intalled OpenCL SDK library
+                          files
+  --with-pic              try to use only PIC/non-PIC objects [default=use
+                          both]
+  --with-gnu-ld           assume the C compiler uses GNU ld [default=no]
+
+Some influential environment variables:
+  CC          C compiler command
+  CFLAGS      C compiler flags
+  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
+              nonstandard directory <lib dir>
+  LIBS        libraries to pass to the linker, e.g. -l<library>
+  CPPFLAGS    C/C++/Objective C preprocessor flags, e.g. -I<include dir> if
+              you have headers in a nonstandard directory <include dir>
+  CPP         C preprocessor
+
+Use these variables to override the choices made by `configure' or to help
+it to find libraries and programs with nonstandard names/locations.
+
+Report bugs to <dark_beer@rambler.ru>.
+_ACEOF
+ac_status=$?
+fi
+
+if test "$ac_init_help" = "recursive"; then
+  # If there are subdirs, report their specific --help.
+  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
+    test -d "$ac_dir" ||
+      { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
+      continue
+    ac_builddir=.
+
+case "$ac_dir" in
+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+*)
+  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
+  # A ".." for each directory in $ac_dir_suffix.
+  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
+  case $ac_top_builddir_sub in
+  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+  esac ;;
+esac
+ac_abs_top_builddir=$ac_pwd
+ac_abs_builddir=$ac_pwd$ac_dir_suffix
+# for backward compatibility:
+ac_top_builddir=$ac_top_build_prefix
+
+case $srcdir in
+  .)  # We are building in place.
+    ac_srcdir=.
+    ac_top_srcdir=$ac_top_builddir_sub
+    ac_abs_top_srcdir=$ac_pwd ;;
+  [\\/]* | ?:[\\/]* )  # Absolute name.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir
+    ac_abs_top_srcdir=$srcdir ;;
+  *) # Relative name.
+    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_build_prefix$srcdir
+    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
+esac
+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+
+    cd "$ac_dir" || { ac_status=$?; continue; }
+    # Check for guested configure.
+    if test -f "$ac_srcdir/configure.gnu"; then
+      echo &&
+      $SHELL "$ac_srcdir/configure.gnu" --help=recursive
+    elif test -f "$ac_srcdir/configure"; then
+      echo &&
+      $SHELL "$ac_srcdir/configure" --help=recursive
+    else
+      $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
+    fi || ac_status=$?
+    cd "$ac_pwd" || { ac_status=$?; break; }
+  done
+fi
+
+test -n "$ac_init_help" && exit $ac_status
+if $ac_init_version; then
+  cat <<\_ACEOF
+OpenACC Runtime Library configure 1.0
+generated by GNU Autoconf 2.64
+
+Copyright (C) 2009 Free Software Foundation, Inc.
+This configure script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it.
+_ACEOF
+  exit
+fi
+
+## ------------------------ ##
+## Autoconf initialization. ##
+## ------------------------ ##
+
+# ac_fn_c_try_compile LINENO
+# --------------------------
+# Try to compile conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_compile ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  rm -f conftest.$ac_objext
+  if { { ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compile") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest.$ac_objext; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_retval=1
+fi
+  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
+  return $ac_retval
+
+} # ac_fn_c_try_compile
+
+# ac_fn_c_try_link LINENO
+# -----------------------
+# Try to link conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_link ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  rm -f conftest.$ac_objext conftest$ac_exeext
+  if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest$ac_exeext && {
+	 test "$cross_compiling" = yes ||
+	 $as_test_x conftest$ac_exeext
+       }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_retval=1
+fi
+  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
+  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
+  # interfere with the next link command; also delete a directory that is
+  # left behind by Apple's compiler.  We do this before executing the actions.
+  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
+  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
+  return $ac_retval
+
+} # ac_fn_c_try_link
+
+# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
+# -------------------------------------------------------
+# Tests whether HEADER exists and can be compiled using the include files in
+# INCLUDES, setting the cache variable VAR accordingly.
+ac_fn_c_check_header_compile ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+#include <$2>
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  eval "$3=yes"
+else
+  eval "$3=no"
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
+
+} # ac_fn_c_check_header_compile
+
+# ac_fn_c_try_cpp LINENO
+# ----------------------
+# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_cpp ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if { { ac_try="$ac_cpp conftest.$ac_ext"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } >/dev/null && {
+	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+    ac_retval=1
+fi
+  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
+  return $ac_retval
+
+} # ac_fn_c_try_cpp
+
+# ac_fn_c_try_run LINENO
+# ----------------------
+# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
+# that executables *can* be run.
+ac_fn_c_try_run ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
+  { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: program exited with status $ac_status" >&5
+       $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+       ac_retval=$ac_status
+fi
+  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
+  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
+  return $ac_retval
+
+} # ac_fn_c_try_run
+
+# ac_fn_c_check_func LINENO FUNC VAR
+# ----------------------------------
+# Tests whether FUNC exists, setting the cache variable VAR accordingly
+ac_fn_c_check_func ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+/* Define $2 to an innocuous variant, in case <limits.h> declares $2.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define $2 innocuous_$2
+
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char $2 (); below.
+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+    <limits.h> exists even on freestanding compilers.  */
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+
+#undef $2
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char $2 ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_$2 || defined __stub___$2
+choke me
+#endif
+
+int
+main ()
+{
+return $2 ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  eval "$3=yes"
+else
+  eval "$3=no"
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
+
+} # ac_fn_c_check_func
+
+# ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
+# -------------------------------------------------------
+# Tests whether HEADER exists, giving a warning if it cannot be compiled using
+# the include files in INCLUDES and setting the cache variable VAR
+# accordingly.
+ac_fn_c_check_header_mongrel ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
+  $as_echo_n "(cached) " >&6
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+else
+  # Is the header compilable?
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
+$as_echo_n "checking $2 usability... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+#include <$2>
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_header_compiler=yes
+else
+  ac_header_compiler=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
+$as_echo "$ac_header_compiler" >&6; }
+
+# Is the header present?
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
+$as_echo_n "checking $2 presence... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <$2>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  ac_header_preproc=yes
+else
+  ac_header_preproc=no
+fi
+rm -f conftest.err conftest.$ac_ext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
+$as_echo "$ac_header_preproc" >&6; }
+
+# So?  What about this header?
+case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #((
+  yes:no: )
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
+$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
+$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
+    ;;
+  no:yes:* )
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
+$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
+$as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
+$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
+$as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
+$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
+( cat <<\_ASBOX
+## ----------------------------------- ##
+## Report this to dark_beer@rambler.ru ##
+## ----------------------------------- ##
+_ASBOX
+     ) | sed "s/^/$as_me: WARNING:     /" >&2
+    ;;
+esac
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
+  $as_echo_n "(cached) " >&6
+else
+  eval "$3=\$ac_header_compiler"
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+fi
+  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
+
+} # ac_fn_c_check_header_mongrel
+
+# ac_fn_c_check_type LINENO TYPE VAR INCLUDES
+# -------------------------------------------
+# Tests whether TYPE exists after having included INCLUDES, setting cache
+# variable VAR accordingly.
+ac_fn_c_check_type ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
+  $as_echo_n "(cached) " >&6
+else
+  eval "$3=no"
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+int
+main ()
+{
+if (sizeof ($2))
+	 return 0;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+int
+main ()
+{
+if (sizeof (($2)))
+	    return 0;
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+
+else
+  eval "$3=yes"
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
+
+} # ac_fn_c_check_type
+cat >config.log <<_ACEOF
+This file contains any messages produced by compilers while
+running configure, to aid debugging if configure makes a mistake.
+
+It was created by OpenACC Runtime Library $as_me 1.0, which was
+generated by GNU Autoconf 2.64.  Invocation command line was
+
+  $ $0 $@
+
+_ACEOF
+exec 5>>config.log
+{
+cat <<_ASUNAME
+## --------- ##
+## Platform. ##
+## --------- ##
+
+hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
+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 || echo unknown`
+/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
+
+/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
+/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
+/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
+/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
+/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
+/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
+
+_ASUNAME
+
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    $as_echo "PATH: $as_dir"
+  done
+IFS=$as_save_IFS
+
+} >&5
+
+cat >&5 <<_ACEOF
+
+
+## ----------- ##
+## Core tests. ##
+## ----------- ##
+
+_ACEOF
+
+
+# Keep a trace of the command line.
+# Strip out --no-create and --no-recursion so they do not pile up.
+# Strip out --silent because we don't want to record it for future runs.
+# Also quote any args containing shell meta-characters.
+# Make two passes to allow for proper duplicate-argument suppression.
+ac_configure_args=
+ac_configure_args0=
+ac_configure_args1=
+ac_must_keep_next=false
+for ac_pass in 1 2
+do
+  for ac_arg
+  do
+    case $ac_arg in
+    -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
+    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+    | -silent | --silent | --silen | --sile | --sil)
+      continue ;;
+    *\'*)
+      ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    esac
+    case $ac_pass in
+    1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
+    2)
+      as_fn_append ac_configure_args1 " '$ac_arg'"
+      if test $ac_must_keep_next = true; then
+	ac_must_keep_next=false # Got value, back to normal.
+      else
+	case $ac_arg in
+	  *=* | --config-cache | -C | -disable-* | --disable-* \
+	  | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
+	  | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
+	  | -with-* | --with-* | -without-* | --without-* | --x)
+	    case "$ac_configure_args0 " in
+	      "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
+	    esac
+	    ;;
+	  -* ) ac_must_keep_next=true ;;
+	esac
+      fi
+      as_fn_append ac_configure_args " '$ac_arg'"
+      ;;
+    esac
+  done
+done
+{ ac_configure_args0=; unset ac_configure_args0;}
+{ ac_configure_args1=; unset ac_configure_args1;}
+
+# When interrupted or exit'd, cleanup temporary files, and complete
+# config.log.  We remove comments because anyway the quotes in there
+# would cause problems or look ugly.
+# WARNING: Use '\'' to represent an apostrophe within the trap.
+# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
+trap 'exit_status=$?
+  # Save into config.log some information that might help in debugging.
+  {
+    echo
+
+    cat <<\_ASBOX
+## ---------------- ##
+## Cache variables. ##
+## ---------------- ##
+_ASBOX
+    echo
+    # The following way of writing the cache mishandles newlines in values,
+(
+  for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
+    eval ac_val=\$$ac_var
+    case $ac_val in #(
+    *${as_nl}*)
+      case $ac_var in #(
+      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
+$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+      esac
+      case $ac_var in #(
+      _ | IFS | as_nl) ;; #(
+      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
+      *) { eval $ac_var=; unset $ac_var;} ;;
+      esac ;;
+    esac
+  done
+  (set) 2>&1 |
+    case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
+    *${as_nl}ac_space=\ *)
+      sed -n \
+	"s/'\''/'\''\\\\'\'''\''/g;
+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
+      ;; #(
+    *)
+      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+      ;;
+    esac |
+    sort
+)
+    echo
+
+    cat <<\_ASBOX
+## ----------------- ##
+## Output variables. ##
+## ----------------- ##
+_ASBOX
+    echo
+    for ac_var in $ac_subst_vars
+    do
+      eval ac_val=\$$ac_var
+      case $ac_val in
+      *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+      esac
+      $as_echo "$ac_var='\''$ac_val'\''"
+    done | sort
+    echo
+
+    if test -n "$ac_subst_files"; then
+      cat <<\_ASBOX
+## ------------------- ##
+## File substitutions. ##
+## ------------------- ##
+_ASBOX
+      echo
+      for ac_var in $ac_subst_files
+      do
+	eval ac_val=\$$ac_var
+	case $ac_val in
+	*\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+	esac
+	$as_echo "$ac_var='\''$ac_val'\''"
+      done | sort
+      echo
+    fi
+
+    if test -s confdefs.h; then
+      cat <<\_ASBOX
+## ----------- ##
+## confdefs.h. ##
+## ----------- ##
+_ASBOX
+      echo
+      cat confdefs.h
+      echo
+    fi
+    test "$ac_signal" != 0 &&
+      $as_echo "$as_me: caught signal $ac_signal"
+    $as_echo "$as_me: exit $exit_status"
+  } >&5
+  rm -f core *.core core.conftest.* &&
+    rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
+    exit $exit_status
+' 0
+for ac_signal in 1 2 13 15; do
+  trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
+done
+ac_signal=0
+
+# confdefs.h avoids OS command line length limits that DEFS can exceed.
+rm -f -r conftest* confdefs.h
+
+$as_echo "/* confdefs.h */" > confdefs.h
+
+# Predefined preprocessor variables.
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_NAME "$PACKAGE_NAME"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_VERSION "$PACKAGE_VERSION"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_STRING "$PACKAGE_STRING"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_URL "$PACKAGE_URL"
+_ACEOF
+
+
+# Let the site file select an alternate cache file if it wants to.
+# Prefer an explicitly selected file to automatically selected ones.
+ac_site_file1=NONE
+ac_site_file2=NONE
+if test -n "$CONFIG_SITE"; then
+  ac_site_file1=$CONFIG_SITE
+elif test "x$prefix" != xNONE; then
+  ac_site_file1=$prefix/share/config.site
+  ac_site_file2=$prefix/etc/config.site
+else
+  ac_site_file1=$ac_default_prefix/share/config.site
+  ac_site_file2=$ac_default_prefix/etc/config.site
+fi
+for ac_site_file in "$ac_site_file1" "$ac_site_file2"
+do
+  test "x$ac_site_file" = xNONE && continue
+  if test -r "$ac_site_file"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
+$as_echo "$as_me: loading site script $ac_site_file" >&6;}
+    sed 's/^/| /' "$ac_site_file" >&5
+    . "$ac_site_file"
+  fi
+done
+
+if test -r "$cache_file"; then
+  # Some versions of bash will fail to source /dev/null (special
+  # files actually), so we avoid doing that.
+  if test -f "$cache_file"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
+$as_echo "$as_me: loading cache $cache_file" >&6;}
+    case $cache_file in
+      [\\/]* | ?:[\\/]* ) . "$cache_file";;
+      *)                      . "./$cache_file";;
+    esac
+  fi
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
+$as_echo "$as_me: creating cache $cache_file" >&6;}
+  >$cache_file
+fi
+
+# Check that the precious variables saved in the cache have kept the same
+# value.
+ac_cache_corrupted=false
+for ac_var in $ac_precious_vars; do
+  eval ac_old_set=\$ac_cv_env_${ac_var}_set
+  eval ac_new_set=\$ac_env_${ac_var}_set
+  eval ac_old_val=\$ac_cv_env_${ac_var}_value
+  eval ac_new_val=\$ac_env_${ac_var}_value
+  case $ac_old_set,$ac_new_set in
+    set,)
+      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
+$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
+      ac_cache_corrupted=: ;;
+    ,set)
+      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
+$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
+      ac_cache_corrupted=: ;;
+    ,);;
+    *)
+      if test "x$ac_old_val" != "x$ac_new_val"; then
+	# differences in whitespace do not lead to failure.
+	ac_old_val_w=`echo x $ac_old_val`
+	ac_new_val_w=`echo x $ac_new_val`
+	if test "$ac_old_val_w" != "$ac_new_val_w"; then
+	  { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
+$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
+	  ac_cache_corrupted=:
+	else
+	  { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
+$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
+	  eval $ac_var=\$ac_old_val
+	fi
+	{ $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
+$as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
+	{ $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
+$as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
+      fi;;
+  esac
+  # Pass precious variables to config.status.
+  if test "$ac_new_set" = set; then
+    case $ac_new_val in
+    *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
+    *) ac_arg=$ac_var=$ac_new_val ;;
+    esac
+    case " $ac_configure_args " in
+      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
+      *) as_fn_append ac_configure_args " '$ac_arg'" ;;
+    esac
+  fi
+done
+if $ac_cache_corrupted; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+  { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
+$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
+  as_fn_error "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
+fi
+## -------------------- ##
+## Main body of script. ##
+## -------------------- ##
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for --enable-version-specific-runtime-libs" >&5
+$as_echo_n "checking for --enable-version-specific-runtime-libs... " >&6; }
+ # Check whether --enable-version-specific-runtime-libs was given.
+if test "${enable_version_specific_runtime_libs+set}" = set; then :
+  enableval=$enable_version_specific_runtime_libs;
+      case "$enableval" in
+       yes|no) ;;
+       *) as_fn_error "Unknown argument to enable/disable version-specific-runtime-libs" "$LINENO" 5 ;;
+                          esac
+
+else
+  enable_version_specific_runtime_libs=no
+fi
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_version_specific_runtime_libs" >&5
+$as_echo "$enable_version_specific_runtime_libs" >&6; }
+
+# We would like our source tree to be readonly. However when releases or
+# pre-releases are generated, the flex/bison generated files as well as the
+# various formats of manuals need to be included along with the rest of the
+# sources.  Therefore we have --enable-generated-files-in-srcdir to do
+# just that.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for --enable-generated-files-in-srcdir" >&5
+$as_echo_n "checking for --enable-generated-files-in-srcdir... " >&6; }
+ # Check whether --enable-generated-files-in-srcdir was given.
+if test "${enable_generated_files_in_srcdir+set}" = set; then :
+  enableval=$enable_generated_files_in_srcdir;
+      case "$enableval" in
+       yes|no) ;;
+       *) as_fn_error "Unknown argument to enable/disable generated-files-in-srcdir" "$LINENO" 5 ;;
+                          esac
+
+else
+  enable_generated_files_in_srcdir=no
+fi
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_generated_files_in_srcdir" >&5
+$as_echo "$enable_generated_files_in_srcdir" >&6; }
+ if test "$enable_generated_files_in_srcdir" = yes; then
+  GENINSRC_TRUE=
+  GENINSRC_FALSE='#'
+else
+  GENINSRC_TRUE='#'
+  GENINSRC_FALSE=
+fi
+
+
+
+# -------
+# -------
+
+# Gets build, host, target, *_vendor, *_cpu, *_os, etc.
+#
+# You will slowly go insane if you do not grok the following fact:  when
+# building this library, the top-level /target/ becomes the library's /host/.
+#
+# configure then causes --target to default to --host, exactly like any
+# other package using autoconf.  Therefore, 'target' and 'host' will
+# always be the same.  This makes sense both for native and cross compilers
+# just think about it for a little while.  :-)
+#
+# Also, if this library is being configured as part of a cross compiler, the
+# top-level configure script will pass the "real" host as $with_cross_host.
+#
+# Do not delete or change the following two lines.  For why, see
+# http://gcc.gnu.org/ml/libstdc++/2003-07/msg00451.html
+ac_aux_dir=
+for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do
+  for ac_t in install-sh install.sh shtool; do
+    if test -f "$ac_dir/$ac_t"; then
+      ac_aux_dir=$ac_dir
+      ac_install_sh="$ac_aux_dir/$ac_t -c"
+      break 2
+    fi
+  done
+done
+if test -z "$ac_aux_dir"; then
+  as_fn_error "cannot find install-sh, install.sh, or shtool in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" "$LINENO" 5
+fi
+
+# These three variables are undocumented and unsupported,
+# and are intended to be withdrawn in a future Autoconf release.
+# They can cause serious problems if a builder's source tree is in a directory
+# whose full name contains unusual characters.
+ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
+ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
+ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
+
+
+# Make sure we can run config.sub.
+$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
+  as_fn_error "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
+$as_echo_n "checking build system type... " >&6; }
+if test "${ac_cv_build+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_build_alias=$build_alias
+test "x$ac_build_alias" = x &&
+  ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
+test "x$ac_build_alias" = x &&
+  as_fn_error "cannot guess build type; you must specify one" "$LINENO" 5
+ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
+  as_fn_error "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
+$as_echo "$ac_cv_build" >&6; }
+case $ac_cv_build in
+*-*-*) ;;
+*) as_fn_error "invalid value of canonical build" "$LINENO" 5;;
+esac
+build=$ac_cv_build
+ac_save_IFS=$IFS; IFS='-'
+set x $ac_cv_build
+shift
+build_cpu=$1
+build_vendor=$2
+shift; shift
+# Remember, the first character of IFS is used to create $*,
+# except with old shells:
+build_os=$*
+IFS=$ac_save_IFS
+case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
+$as_echo_n "checking host system type... " >&6; }
+if test "${ac_cv_host+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test "x$host_alias" = x; then
+  ac_cv_host=$ac_cv_build
+else
+  ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
+    as_fn_error "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
+$as_echo "$ac_cv_host" >&6; }
+case $ac_cv_host in
+*-*-*) ;;
+*) as_fn_error "invalid value of canonical host" "$LINENO" 5;;
+esac
+host=$ac_cv_host
+ac_save_IFS=$IFS; IFS='-'
+set x $ac_cv_host
+shift
+host_cpu=$1
+host_vendor=$2
+shift; shift
+# Remember, the first character of IFS is used to create $*,
+# except with old shells:
+host_os=$*
+IFS=$ac_save_IFS
+case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5
+$as_echo_n "checking target system type... " >&6; }
+if test "${ac_cv_target+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test "x$target_alias" = x; then
+  ac_cv_target=$ac_cv_host
+else
+  ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
+    as_fn_error "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5
+$as_echo "$ac_cv_target" >&6; }
+case $ac_cv_target in
+*-*-*) ;;
+*) as_fn_error "invalid value of canonical target" "$LINENO" 5;;
+esac
+target=$ac_cv_target
+ac_save_IFS=$IFS; IFS='-'
+set x $ac_cv_target
+shift
+target_cpu=$1
+target_vendor=$2
+shift; shift
+# Remember, the first character of IFS is used to create $*,
+# except with old shells:
+target_os=$*
+IFS=$ac_save_IFS
+case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac
+
+
+# The aliases save the names the user supplied, while $host etc.
+# will get canonicalized.
+test -n "$target_alias" &&
+  test "$program_prefix$program_suffix$program_transform_name" = \
+    NONENONEs,x,x, &&
+  program_prefix=${target_alias}-
+
+target_alias=${target_alias-$host_alias}
+
+am__api_version='1.12'
+
+# Find a good install program.  We prefer a C program (faster),
+# so one script is as good as another.  But avoid the broken or
+# incompatible versions:
+# SysV /etc/install, /usr/sbin/install
+# SunOS /usr/etc/install
+# IRIX /sbin/install
+# AIX /bin/install
+# AmigaOS /C/install, which installs bootblocks on floppy discs
+# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
+# AFS /usr/afsws/bin/install, which mishandles nonexistent args
+# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
+# OS/2's system install, which has a completely different semantic
+# ./install, which can be erroneously created by make from ./install.sh.
+# Reject install programs that cannot install multiple files.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
+$as_echo_n "checking for a BSD-compatible install... " >&6; }
+if test -z "$INSTALL"; then
+if test "${ac_cv_path_install+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    # Account for people who put trailing slashes in PATH elements.
+case $as_dir/ in #((
+  ./ | .// | /[cC]/* | \
+  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
+  ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \
+  /usr/ucb/* ) ;;
+  *)
+    # OSF1 and SCO ODT 3.0 have their own names for install.
+    # Don't use installbsd from OSF since it installs stuff as root
+    # by default.
+    for ac_prog in ginstall scoinst install; do
+      for ac_exec_ext in '' $ac_executable_extensions; do
+	if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
+	  if test $ac_prog = install &&
+	    grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+	    # AIX install.  It has an incompatible calling convention.
+	    :
+	  elif test $ac_prog = install &&
+	    grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+	    # program-specific install script used by HP pwplus--don't use.
+	    :
+	  else
+	    rm -rf conftest.one conftest.two conftest.dir
+	    echo one > conftest.one
+	    echo two > conftest.two
+	    mkdir conftest.dir
+	    if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
+	      test -s conftest.one && test -s conftest.two &&
+	      test -s conftest.dir/conftest.one &&
+	      test -s conftest.dir/conftest.two
+	    then
+	      ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
+	      break 3
+	    fi
+	  fi
+	fi
+      done
+    done
+    ;;
+esac
+
+  done
+IFS=$as_save_IFS
+
+rm -rf conftest.one conftest.two conftest.dir
+
+fi
+  if test "${ac_cv_path_install+set}" = set; then
+    INSTALL=$ac_cv_path_install
+  else
+    # As a last resort, use the slow shell script.  Don't cache a
+    # value for INSTALL within a source directory, because that will
+    # break other packages using the cache if that directory is
+    # removed, or if the value is a relative name.
+    INSTALL=$ac_install_sh
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
+$as_echo "$INSTALL" >&6; }
+
+# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
+# It thinks the first close brace ends the variable substitution.
+test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
+
+test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
+
+test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5
+$as_echo_n "checking whether build environment is sane... " >&6; }
+# 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]*)
+    as_fn_error "unsafe absolute working directory name" "$LINENO" 5;;
+esac
+case $srcdir in
+  *[\\\"\#\$\&\'\`$am_lf\ \	]*)
+    as_fn_error "unsafe srcdir value: '$srcdir'" "$LINENO" 5;;
+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".
+	as_fn_error "ls -t appears to fail.  Make sure there is not a broken
+  alias in your environment" "$LINENO" 5
+     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
+   as_fn_error "newly created file is older than distributed files!
+Check your system clock" "$LINENO" 5
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+# 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
+
+rm -f conftest.file
+
+test "$program_prefix" != NONE &&
+  program_transform_name="s&^&$program_prefix&;$program_transform_name"
+# Use a double $ so make ignores it.
+test "$program_suffix" != NONE &&
+  program_transform_name="s&\$&$program_suffix&;$program_transform_name"
+# Double any \ or $.
+# By default was `s,x,x', remove it if useless.
+ac_script='s/[\\$]/&&/g;s/;s,x,x,$//'
+program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"`
+
+# expand $ac_aux_dir to an absolute path
+am_aux_dir=`cd $ac_aux_dir && pwd`
+
+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 --run true"; then
+  am_missing_run="$MISSING --run "
+else
+  am_missing_run=
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: 'missing' script is too old or missing" >&5
+$as_echo "$as_me: WARNING: 'missing' script is too old or missing" >&2;}
+fi
+
+if test x"${install_sh}" != 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
+
+# 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.
+if test "$cross_compiling" != no; then
+  if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
+set dummy ${ac_tool_prefix}strip; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_STRIP+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$STRIP"; then
+  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+STRIP=$ac_cv_prog_STRIP
+if test -n "$STRIP"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
+$as_echo "$STRIP" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_STRIP"; then
+  ac_ct_STRIP=$STRIP
+  # Extract the first word of "strip", so it can be a program name with args.
+set dummy strip; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_STRIP"; then
+  ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_ac_ct_STRIP="strip"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+if test -n "$ac_ct_STRIP"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
+$as_echo "$ac_ct_STRIP" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_STRIP" = x; then
+    STRIP=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    STRIP=$ac_ct_STRIP
+  fi
+else
+  STRIP="$ac_cv_prog_STRIP"
+fi
+
+fi
+INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a thread-safe mkdir -p" >&5
+$as_echo_n "checking for a thread-safe mkdir -p... " >&6; }
+if test -z "$MKDIR_P"; then
+  if test "${ac_cv_path_mkdir+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in mkdir gmkdir; do
+	 for ac_exec_ext in '' $ac_executable_extensions; do
+	   { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; } || continue
+	   case `"$as_dir/$ac_prog$ac_exec_ext" --version 2>&1` in #(
+	     'mkdir (GNU coreutils) '* | \
+	     'mkdir (coreutils) '* | \
+	     'mkdir (fileutils) '4.1*)
+	       ac_cv_path_mkdir=$as_dir/$ac_prog$ac_exec_ext
+	       break 3;;
+	   esac
+	 done
+       done
+  done
+IFS=$as_save_IFS
+
+fi
+
+  if test "${ac_cv_path_mkdir+set}" = set; then
+    MKDIR_P="$ac_cv_path_mkdir -p"
+  else
+    # As a last resort, use the slow shell script.  Don't cache a
+    # value for MKDIR_P within a source directory, because that will
+    # break other packages using the cache if that directory is
+    # removed, or if the value is a relative name.
+    test -d ./--version && rmdir ./--version
+    MKDIR_P="$ac_install_sh -d"
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5
+$as_echo "$MKDIR_P" >&6; }
+
+for ac_prog in gawk mawk nawk awk
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_AWK+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$AWK"; then
+  ac_cv_prog_AWK="$AWK" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_AWK="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+AWK=$ac_cv_prog_AWK
+if test -n "$AWK"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
+$as_echo "$AWK" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$AWK" && break
+done
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
+$as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
+set x ${MAKE-make}
+ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
+if { as_var=ac_cv_prog_make_${ac_make}_set; eval "test \"\${$as_var+set}\" = set"; }; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat >conftest.make <<\_ACEOF
+SHELL = /bin/sh
+all:
+	@echo '@@@%%%=$(MAKE)=@@@%%%'
+_ACEOF
+# GNU make sometimes prints "make[1]: Entering...", which would confuse us.
+case `${MAKE-make} -f conftest.make 2>/dev/null` in
+  *@@@%%%=?*=@@@%%%*)
+    eval ac_cv_prog_make_${ac_make}_set=yes;;
+  *)
+    eval ac_cv_prog_make_${ac_make}_set=no;;
+esac
+rm -f conftest.make
+fi
+if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+  SET_MAKE=
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+  SET_MAKE="MAKE=${MAKE-make}"
+fi
+
+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
+
+if test "`cd $srcdir && pwd`" != "`pwd`"; then
+  # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
+  # is not polluted with repeated "-I."
+  am__isrc=' -I$(srcdir)'
+  # test to see if srcdir already configured
+  if test -f $srcdir/config.status; then
+    as_fn_error "source directory already configured; run \"make distclean\" there first" "$LINENO" 5
+  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
+
+
+# Define the identity of the package.
+ PACKAGE='openacc-runtime-library'
+ VERSION='1.0'
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE "$PACKAGE"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define VERSION "$VERSION"
+_ACEOF
+
+# Some tools Automake needs.
+
+ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"}
+
+
+AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"}
+
+
+AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"}
+
+
+AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"}
+
+
+MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}
+
+# 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>
+mkdir_p='$(MKDIR_P)'
+
+# We need awk for the "check" target.  The system "awk" is bad on
+# some platforms.
+# Always define AMTAR for backward compatibility.  Yes, it's still used
+# in the wild :-(  We should find a proper way to deprecate it ...
+AMTAR='$${TAR-tar}'
+
+am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'
+
+
+
+
+
+# Default to --enable-multilib
+# Check whether --enable-multilib was given.
+if test "${enable_multilib+set}" = set; then :
+  enableval=$enable_multilib; case "$enableval" in
+  yes) multilib=yes ;;
+  no)  multilib=no ;;
+  *)   as_fn_error "bad value $enableval for multilib option" "$LINENO" 5 ;;
+ esac
+else
+  multilib=yes
+fi
+
+
+# We may get other options which we leave undocumented:
+# --with-target-subdir, --with-multisrctop, --with-multisubdir
+# See config-ml.in if you want the gory details.
+
+if test "$srcdir" = "."; then
+  if test "$with_target_subdir" != "."; then
+    multi_basedir="$srcdir/$with_multisrctop../.."
+  else
+    multi_basedir="$srcdir/$with_multisrctop.."
+  fi
+else
+  multi_basedir="$srcdir/.."
+fi
+
+
+# Even if the default multilib is not a cross compilation,
+# it may be that some of the other multilibs are.
+if test $cross_compiling = no && test $multilib = yes \
+   && test "x${with_multisubdir}" != x ; then
+   cross_compiling=maybe
+fi
+
+ac_config_commands="$ac_config_commands default-1"
+
+
+# Calculate toolexeclibdir
+# Also toolexecdir, though it's only used in toolexeclibdir
+case ${enable_version_specific_runtime_libs} in
+  yes)
+    # Need the gcc compiler version to know where to install libraries
+    # and header files if --enable-version-specific-runtime-libs option
+    # is selected.
+    toolexecdir='$(libdir)/gcc/$(target_alias)'
+    toolexeclibdir='$(toolexecdir)/$(gcc_version)$(MULTISUBDIR)'
+    ;;
+  no)
+    if test -n "$with_cross_host" &&
+       test x"$with_cross_host" != x"no"; then
+      # Install a library built with a cross compiler in tooldir, not libdir.
+      toolexecdir='$(exec_prefix)/$(target_alias)'
+      toolexeclibdir='$(toolexecdir)/lib'
+    else
+      toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
+      toolexeclibdir='$(libdir)'
+    fi
+    multi_os_directory=`$CC -print-multi-os-directory`
+    case $multi_os_directory in
+      .) ;; # Avoid trailing /.
+      *) toolexeclibdir=$toolexeclibdir/$multi_os_directory ;;
+    esac
+    ;;
+esac
+
+
+
+
+
+# Checks for options.
+opencl=
+openclinc=
+opencllib=
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for OpenCL options" >&5
+$as_echo_n "checking for OpenCL options... " >&6; }
+
+# Check whether --with-opencl was given.
+if test "${with_opencl+set}" = set; then :
+  withval=$with_opencl; opencl=${withval}
+fi
+
+
+# Check whether --with-opencl-include was given.
+if test "${with_opencl_include+set}" = set; then :
+  withval=$with_opencl_include; openclinc=${withval}
+fi
+
+
+# Check whether --with-opencl-lib was given.
+if test "${with_opencl_lib+set}" = set; then :
+  withval=$with_opencl_lib; opencllib=${withval}
+fi
+
+
+if test "x$openclinc" == x ; then
+	if test "x$opencl" != x ; then
+		openclinc="${opencl}/include"
+	else
+		{ as_fn_set_status 1
+as_fn_error "This library requires OpenCL SDK path specified in --with-opencl option" "$LINENO" 5; }
+	fi
+fi
+
+if test "x$opencllib" == x ; then
+	if test "x$opencl" != x ; then
+		opencllib="${opencl}/lib"
+	fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $openclinc" >&5
+$as_echo "$openclinc" >&6; }
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for thread model used by GCC" >&5
+$as_echo_n "checking for thread model used by GCC... " >&6; }
+THREADS=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'`
+if test x"$THREADS" == x; then
+   THREADS=no
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $THREADS" >&5
+$as_echo "$THREADS" >&6; }
+
+# THREADCFLAGS=
+THREADLIBS=
+
+case "$THREADS" in
+ no | none | single)
+    THREADS=none
+    ;;
+ posix | pthreads)
+    THREADS=posix
+    THREADLIBS=-lpthread
+    ;;
+ *)
+    as_fn_error "$THREADS library is not supported" "$LINENO" 5
+    ;;
+esac
+
+# AC_SUBST(THREADCFLAGS)
+
+
+
+# Checks for programs.
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}gcc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_CC+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_CC="${ac_tool_prefix}gcc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_CC"; then
+  ac_ct_CC=$CC
+  # Extract the first word of "gcc", so it can be a program name with args.
+set dummy gcc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_ac_ct_CC="gcc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+$as_echo "$ac_ct_CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_CC" = x; then
+    CC=""
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC=$ac_ct_CC
+  fi
+else
+  CC="$ac_cv_prog_CC"
+fi
+
+if test -z "$CC"; then
+          if test -n "$ac_tool_prefix"; then
+    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}cc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_CC+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_CC="${ac_tool_prefix}cc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  fi
+fi
+if test -z "$CC"; then
+  # Extract the first word of "cc", so it can be a program name with args.
+set dummy cc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_CC+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+  ac_prog_rejected=no
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+       ac_prog_rejected=yes
+       continue
+     fi
+    ac_cv_prog_CC="cc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+if test $ac_prog_rejected = yes; then
+  # We found a bogon in the path, so make sure we never use it.
+  set dummy $ac_cv_prog_CC
+  shift
+  if test $# != 0; then
+    # We chose a different compiler from the bogus one.
+    # However, it has the same basename, so the bogon will be chosen
+    # first if we set CC to just the basename; use the full file name.
+    shift
+    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
+  fi
+fi
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$CC"; then
+  if test -n "$ac_tool_prefix"; then
+  for ac_prog in cl.exe
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_CC+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+    test -n "$CC" && break
+  done
+fi
+if test -z "$CC"; then
+  ac_ct_CC=$CC
+  for ac_prog in cl.exe
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_ac_ct_CC="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+$as_echo "$ac_ct_CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$ac_ct_CC" && break
+done
+
+  if test "x$ac_ct_CC" = x; then
+    CC=""
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC=$ac_ct_CC
+  fi
+fi
+
+fi
+
+
+test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error "no acceptable C compiler found in \$PATH
+See \`config.log' for more details." "$LINENO" 5; }
+
+# Provide some information about the compiler.
+$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
+set X $ac_compile
+ac_compiler=$2
+for ac_option in --version -v -V -qversion; do
+  { { ac_try="$ac_compiler $ac_option >&5"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    sed '10a\
+... rest of stderr output deleted ...
+         10q' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    rm -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+done
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out conftest.out"
+# Try to create an executable without -o first, disregard a.out.
+# It will help us diagnose broken compilers, and finding out an intuition
+# of exeext.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
+$as_echo_n "checking for C compiler default output file name... " >&6; }
+ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
+
+# The possible output files:
+ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
+
+ac_rmfiles=
+for ac_file in $ac_files
+do
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
+    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
+  esac
+done
+rm -f $ac_rmfiles
+
+if { { ac_try="$ac_link_default"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link_default") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
+# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
+# in a Makefile.  We should not override ac_cv_exeext if it was cached,
+# so that the user can short-circuit this test for compilers unknown to
+# Autoconf.
+for ac_file in $ac_files ''
+do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
+	;;
+    [ab].out )
+	# We found the default executable, but exeext='' is most
+	# certainly right.
+	break;;
+    *.* )
+	if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
+	then :; else
+	   ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+	fi
+	# We set ac_cv_exeext here because the later test for it is not
+	# safe: cross compilers may not add the suffix if given an `-o'
+	# argument, so we may need to know it at that point already.
+	# Even if this section looks crufty: it has the advantage of
+	# actually working.
+	break;;
+    * )
+	break;;
+  esac
+done
+test "$ac_cv_exeext" = no && ac_cv_exeext=
+
+else
+  ac_file=''
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
+$as_echo "$ac_file" >&6; }
+if test -z "$ac_file"; then :
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+{ as_fn_set_status 77
+as_fn_error "C compiler cannot create executables
+See \`config.log' for more details." "$LINENO" 5; }; }
+fi
+ac_exeext=$ac_cv_exeext
+
+# Check that the compiler produces executables we can run.  If not, either
+# the compiler is broken, or we cross compile.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
+$as_echo_n "checking whether the C compiler works... " >&6; }
+# If not cross compiling, check that we can run a simple program.
+if test "$cross_compiling" != yes; then
+  if { ac_try='./$ac_file'
+  { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }; then
+    cross_compiling=no
+  else
+    if test "$cross_compiling" = maybe; then
+	cross_compiling=yes
+    else
+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error "cannot run C compiled programs.
+If you meant to cross compile, use \`--host'.
+See \`config.log' for more details." "$LINENO" 5; }
+    fi
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+
+rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out conftest.out
+ac_clean_files=$ac_clean_files_save
+# Check that the compiler produces executables we can run.  If not, either
+# the compiler is broken, or we cross compile.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
+$as_echo_n "checking whether we are cross compiling... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
+$as_echo "$cross_compiling" >&6; }
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
+$as_echo_n "checking for suffix of executables... " >&6; }
+if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  # If both `conftest.exe' and `conftest' are `present' (well, observable)
+# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
+# work properly (i.e., refer to `conftest.exe'), while it won't with
+# `rm'.
+for ac_file in conftest.exe conftest conftest.*; do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
+    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+	  break;;
+    * ) break;;
+  esac
+done
+else
+  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error "cannot compute suffix of executables: cannot compile and link
+See \`config.log' for more details." "$LINENO" 5; }
+fi
+rm -f conftest$ac_cv_exeext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
+$as_echo "$ac_cv_exeext" >&6; }
+
+rm -f conftest.$ac_ext
+EXEEXT=$ac_cv_exeext
+ac_exeext=$EXEEXT
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
+$as_echo_n "checking for suffix of object files... " >&6; }
+if test "${ac_cv_objext+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.o conftest.obj
+if { { ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compile") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  for ac_file in conftest.o conftest.obj conftest.*; do
+  test -f "$ac_file" || continue;
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
+    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
+       break;;
+  esac
+done
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error "cannot compute suffix of object files: cannot compile
+See \`config.log' for more details." "$LINENO" 5; }
+fi
+rm -f conftest.$ac_cv_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
+$as_echo "$ac_cv_objext" >&6; }
+OBJEXT=$ac_cv_objext
+ac_objext=$OBJEXT
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
+$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
+if test "${ac_cv_c_compiler_gnu+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+#ifndef __GNUC__
+       choke me
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_compiler_gnu=yes
+else
+  ac_compiler_gnu=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ac_cv_c_compiler_gnu=$ac_compiler_gnu
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
+$as_echo "$ac_cv_c_compiler_gnu" >&6; }
+if test $ac_compiler_gnu = yes; then
+  GCC=yes
+else
+  GCC=
+fi
+ac_test_CFLAGS=${CFLAGS+set}
+ac_save_CFLAGS=$CFLAGS
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
+$as_echo_n "checking whether $CC accepts -g... " >&6; }
+if test "${ac_cv_prog_cc_g+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_save_c_werror_flag=$ac_c_werror_flag
+   ac_c_werror_flag=yes
+   ac_cv_prog_cc_g=no
+   CFLAGS="-g"
+   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_g=yes
+else
+  CFLAGS=""
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+
+else
+  ac_c_werror_flag=$ac_save_c_werror_flag
+	 CFLAGS="-g"
+	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_g=yes
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+   ac_c_werror_flag=$ac_save_c_werror_flag
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
+$as_echo "$ac_cv_prog_cc_g" >&6; }
+if test "$ac_test_CFLAGS" = set; then
+  CFLAGS=$ac_save_CFLAGS
+elif test $ac_cv_prog_cc_g = yes; then
+  if test "$GCC" = yes; then
+    CFLAGS="-g -O2"
+  else
+    CFLAGS="-g"
+  fi
+else
+  if test "$GCC" = yes; then
+    CFLAGS="-O2"
+  else
+    CFLAGS=
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
+$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
+if test "${ac_cv_prog_cc_c89+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_cv_prog_cc_c89=no
+ac_save_CC=$CC
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdarg.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
+struct buf { int x; };
+FILE * (*rcsopen) (struct buf *, struct stat *, int);
+static char *e (p, i)
+     char **p;
+     int i;
+{
+  return p[i];
+}
+static char *f (char * (*g) (char **, int), char **p, ...)
+{
+  char *s;
+  va_list v;
+  va_start (v,p);
+  s = g (p, va_arg (v,int));
+  va_end (v);
+  return s;
+}
+
+/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+   function prototypes and stuff, but not '\xHH' hex character constants.
+   These don't provoke an error unfortunately, instead are silently treated
+   as 'x'.  The following induces an error, until -std is added to get
+   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
+   array size at least.  It's necessary to write '\x00'==0 to get something
+   that's true only with -std.  */
+int osf4_cc_array ['\x00' == 0 ? 1 : -1];
+
+/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
+   inside strings and character constants.  */
+#define FOO(x) 'x'
+int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
+
+int test (int i, double x);
+struct s1 {int (*f) (int a);};
+struct s2 {int (*f) (double a);};
+int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
+int argc;
+char **argv;
+int
+main ()
+{
+return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
+  ;
+  return 0;
+}
+_ACEOF
+for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
+	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+do
+  CC="$ac_save_CC $ac_arg"
+  if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_c89=$ac_arg
+fi
+rm -f core conftest.err conftest.$ac_objext
+  test "x$ac_cv_prog_cc_c89" != "xno" && break
+done
+rm -f conftest.$ac_ext
+CC=$ac_save_CC
+
+fi
+# AC_CACHE_VAL
+case "x$ac_cv_prog_cc_c89" in
+  x)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+$as_echo "none needed" >&6; } ;;
+  xno)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+$as_echo "unsupported" >&6; } ;;
+  *)
+    CC="$CC $ac_cv_prog_cc_c89"
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
+$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
+esac
+if test "x$ac_cv_prog_cc_c89" != xno; then :
+
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+DEPDIR="${am__leading_dot}deps"
+
+ac_config_commands="$ac_config_commands depfiles"
+
+
+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.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5
+$as_echo_n "checking for style of include used by $am_make... " >&6; }
+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
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5
+$as_echo "$_am_result" >&6; }
+rm -f confinc confmf
+
+# Check whether --enable-dependency-tracking was given.
+if test "${enable_dependency_tracking+set}" = set; then :
+  enableval=$enable_dependency_tracking;
+fi
+
+if test "x$enable_dependency_tracking" != xno; then
+  am_depcomp="$ac_aux_dir/depcomp"
+  AMDEPBACKSLASH='\'
+  am__nodep='_no'
+fi
+ if test "x$enable_dependency_tracking" != xno; then
+  AMDEP_TRUE=
+  AMDEP_FALSE='#'
+else
+  AMDEP_TRUE='#'
+  AMDEP_FALSE=
+fi
+
+
+
+depcc="$CC"   am_compiler_list=
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
+$as_echo_n "checking dependency style of $depcc... " >&6; }
+if test "${am_cv_CC_dependencies_compiler_type+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  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_CC_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
+  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_CC_dependencies_compiler_type=$depmode
+        break
+      fi
+    fi
+  done
+
+  cd ..
+  rm -rf conftest.dir
+else
+  am_cv_CC_dependencies_compiler_type=none
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5
+$as_echo "$am_cv_CC_dependencies_compiler_type" >&6; }
+CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
+
+ if
+  test "x$enable_dependency_tracking" != xno \
+  && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then
+  am__fastdepCC_TRUE=
+  am__fastdepCC_FALSE='#'
+else
+  am__fastdepCC_TRUE='#'
+  am__fastdepCC_FALSE=
+fi
+
+
+
+if test "x$CC" != xcc; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC and cc understand -c and -o together" >&5
+$as_echo_n "checking whether $CC and cc understand -c and -o together... " >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether cc understands -c and -o together" >&5
+$as_echo_n "checking whether cc understands -c and -o together... " >&6; }
+fi
+set dummy $CC; ac_cc=`$as_echo "$2" |
+		      sed 's/[^a-zA-Z0-9_]/_/g;s/^[0-9]/_/'`
+if { as_var=ac_cv_prog_cc_${ac_cc}_c_o; eval "test \"\${$as_var+set}\" = set"; }; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+# Make sure it works both with $CC and with simple cc.
+# We do the test twice because some compilers refuse to overwrite an
+# existing .o file with -o, though they will create one.
+ac_try='$CC -c conftest.$ac_ext -o conftest2.$ac_objext >&5'
+rm -f conftest2.*
+if { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } &&
+   test -f conftest2.$ac_objext && { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; };
+then
+  eval ac_cv_prog_cc_${ac_cc}_c_o=yes
+  if test "x$CC" != xcc; then
+    # Test first that cc exists at all.
+    if { ac_try='cc -c conftest.$ac_ext >&5'
+  { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }; then
+      ac_try='cc -c conftest.$ac_ext -o conftest2.$ac_objext >&5'
+      rm -f conftest2.*
+      if { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } &&
+	 test -f conftest2.$ac_objext && { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; };
+      then
+	# cc works too.
+	:
+      else
+	# cc exists but doesn't like -o.
+	eval ac_cv_prog_cc_${ac_cc}_c_o=no
+      fi
+    fi
+  fi
+else
+  eval ac_cv_prog_cc_${ac_cc}_c_o=no
+fi
+rm -f core conftest*
+
+fi
+if eval test \$ac_cv_prog_cc_${ac_cc}_c_o = yes; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+
+$as_echo "#define NO_MINUS_C_MINUS_O 1" >>confdefs.h
+
+fi
+
+case `pwd` in
+  *\ * | *\	*)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5
+$as_echo "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;;
+esac
+
+
+
+macro_version='2.2.7a'
+macro_revision='1.3134'
+
+
+
+
+
+
+
+
+
+
+
+
+
+ltmain="$ac_aux_dir/ltmain.sh"
+
+# Backslashify metacharacters that are still active within
+# double-quoted strings.
+sed_quote_subst='s/\(["`$\\]\)/\\\1/g'
+
+# Same as above, but do not quote variable references.
+double_quote_subst='s/\(["`\\]\)/\\\1/g'
+
+# Sed substitution to delay expansion of an escaped shell variable in a
+# double_quote_subst'ed string.
+delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
+
+# Sed substitution to delay expansion of an escaped single quote.
+delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g'
+
+# Sed substitution to avoid accidental globbing in evaled expressions
+no_glob_subst='s/\*/\\\*/g'
+
+ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO
+ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to print strings" >&5
+$as_echo_n "checking how to print strings... " >&6; }
+# Test print first, because it will be a builtin if present.
+if test "X`print -r -- -n 2>/dev/null`" = X-n && \
+   test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then
+  ECHO='print -r --'
+elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then
+  ECHO='printf %s\n'
+else
+  # Use this function as a fallback that always works.
+  func_fallback_echo ()
+  {
+    eval 'cat <<_LTECHO_EOF
+$1
+_LTECHO_EOF'
+  }
+  ECHO='func_fallback_echo'
+fi
+
+# func_echo_all arg...
+# Invoke $ECHO with all args, space-separated.
+func_echo_all ()
+{
+    $ECHO ""
+}
+
+case "$ECHO" in
+  printf*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: printf" >&5
+$as_echo "printf" >&6; } ;;
+  print*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: print -r" >&5
+$as_echo "print -r" >&6; } ;;
+  *) { $as_echo "$as_me:${as_lineno-$LINENO}: result: cat" >&5
+$as_echo "cat" >&6; } ;;
+esac
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
+$as_echo_n "checking for a sed that does not truncate output... " >&6; }
+if test "${ac_cv_path_SED+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+            ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
+     for ac_i in 1 2 3 4 5 6 7; do
+       ac_script="$ac_script$as_nl$ac_script"
+     done
+     echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
+     { ac_script=; unset ac_script;}
+     if test -z "$SED"; then
+  ac_path_SED_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in sed gsed; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
+      { test -f "$ac_path_SED" && $as_test_x "$ac_path_SED"; } || continue
+# Check for GNU ac_path_SED and select it if it is found.
+  # Check for GNU $ac_path_SED
+case `"$ac_path_SED" --version 2>&1` in
+*GNU*)
+  ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo '' >> "conftest.nl"
+    "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_SED_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_SED="$ac_path_SED"
+      ac_path_SED_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_SED_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_SED"; then
+    as_fn_error "no acceptable sed could be found in \$PATH" "$LINENO" 5
+  fi
+else
+  ac_cv_path_SED=$SED
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
+$as_echo "$ac_cv_path_SED" >&6; }
+ SED="$ac_cv_path_SED"
+  rm -f conftest.sed
+
+test -z "$SED" && SED=sed
+Xsed="$SED -e 1s/^X//"
+
+
+
+
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
+$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
+if test "${ac_cv_path_GREP+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -z "$GREP"; then
+  ac_path_GREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in grep ggrep; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
+      { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
+# Check for GNU ac_path_GREP and select it if it is found.
+  # Check for GNU $ac_path_GREP
+case `"$ac_path_GREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo 'GREP' >> "conftest.nl"
+    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_GREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_GREP="$ac_path_GREP"
+      ac_path_GREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_GREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_GREP"; then
+    as_fn_error "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_GREP=$GREP
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
+$as_echo "$ac_cv_path_GREP" >&6; }
+ GREP="$ac_cv_path_GREP"
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
+$as_echo_n "checking for egrep... " >&6; }
+if test "${ac_cv_path_EGREP+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
+   then ac_cv_path_EGREP="$GREP -E"
+   else
+     if test -z "$EGREP"; then
+  ac_path_EGREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in egrep; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
+      { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
+# Check for GNU ac_path_EGREP and select it if it is found.
+  # Check for GNU $ac_path_EGREP
+case `"$ac_path_EGREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo 'EGREP' >> "conftest.nl"
+    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_EGREP="$ac_path_EGREP"
+      ac_path_EGREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_EGREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_EGREP"; then
+    as_fn_error "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_EGREP=$EGREP
+fi
+
+   fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
+$as_echo "$ac_cv_path_EGREP" >&6; }
+ EGREP="$ac_cv_path_EGREP"
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
+$as_echo_n "checking for fgrep... " >&6; }
+if test "${ac_cv_path_FGREP+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
+   then ac_cv_path_FGREP="$GREP -F"
+   else
+     if test -z "$FGREP"; then
+  ac_path_FGREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in fgrep; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
+      { test -f "$ac_path_FGREP" && $as_test_x "$ac_path_FGREP"; } || continue
+# Check for GNU ac_path_FGREP and select it if it is found.
+  # Check for GNU $ac_path_FGREP
+case `"$ac_path_FGREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo 'FGREP' >> "conftest.nl"
+    "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_FGREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_FGREP="$ac_path_FGREP"
+      ac_path_FGREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_FGREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_FGREP"; then
+    as_fn_error "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_FGREP=$FGREP
+fi
+
+   fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
+$as_echo "$ac_cv_path_FGREP" >&6; }
+ FGREP="$ac_cv_path_FGREP"
+
+
+test -z "$GREP" && GREP=grep
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# Check whether --with-gnu-ld was given.
+if test "${with_gnu_ld+set}" = set; then :
+  withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes
+else
+  with_gnu_ld=no
+fi
+
+ac_prog=ld
+if test "$GCC" = yes; then
+  # Check if gcc -print-prog-name=ld gives a path.
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5
+$as_echo_n "checking for ld used by $CC... " >&6; }
+  case $host in
+  *-*-mingw*)
+    # gcc leaves a trailing carriage return which upsets mingw
+    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
+  *)
+    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
+  esac
+  case $ac_prog in
+    # Accept absolute paths.
+    [\\/]* | ?:[\\/]*)
+      re_direlt='/[^/][^/]*/\.\./'
+      # Canonicalize the pathname of ld
+      ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'`
+      while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do
+	ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"`
+      done
+      test -z "$LD" && LD="$ac_prog"
+      ;;
+  "")
+    # If it fails, then pretend we aren't using GCC.
+    ac_prog=ld
+    ;;
+  *)
+    # If it is relative, then search for the first ld in PATH.
+    with_gnu_ld=unknown
+    ;;
+  esac
+elif test "$with_gnu_ld" = yes; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5
+$as_echo_n "checking for GNU ld... " >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5
+$as_echo_n "checking for non-GNU ld... " >&6; }
+fi
+if test "${lt_cv_path_LD+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -z "$LD"; then
+  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+  for ac_dir in $PATH; do
+    IFS="$lt_save_ifs"
+    test -z "$ac_dir" && ac_dir=.
+    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
+      lt_cv_path_LD="$ac_dir/$ac_prog"
+      # Check to see if the program is GNU ld.  I'd rather use --version,
+      # but apparently some variants of GNU ld only accept -v.
+      # Break only if it was the GNU/non-GNU ld that we prefer.
+      case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
+      *GNU* | *'with BFD'*)
+	test "$with_gnu_ld" != no && break
+	;;
+      *)
+	test "$with_gnu_ld" != yes && break
+	;;
+      esac
+    fi
+  done
+  IFS="$lt_save_ifs"
+else
+  lt_cv_path_LD="$LD" # Let the user override the test with a path.
+fi
+fi
+
+LD="$lt_cv_path_LD"
+if test -n "$LD"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
+$as_echo "$LD" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+test -z "$LD" && as_fn_error "no acceptable ld found in \$PATH" "$LINENO" 5
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5
+$as_echo_n "checking if the linker ($LD) is GNU ld... " >&6; }
+if test "${lt_cv_prog_gnu_ld+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  # I'd rather use --version here, but apparently some GNU lds only accept -v.
+case `$LD -v 2>&1 </dev/null` in
+*GNU* | *'with BFD'*)
+  lt_cv_prog_gnu_ld=yes
+  ;;
+*)
+  lt_cv_prog_gnu_ld=no
+  ;;
+esac
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_gnu_ld" >&5
+$as_echo "$lt_cv_prog_gnu_ld" >&6; }
+with_gnu_ld=$lt_cv_prog_gnu_ld
+
+
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BSD- or MS-compatible name lister (nm)" >&5
+$as_echo_n "checking for BSD- or MS-compatible name lister (nm)... " >&6; }
+if test "${lt_cv_path_NM+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$NM"; then
+  # Let the user override the test.
+  lt_cv_path_NM="$NM"
+else
+  lt_nm_to_check="${ac_tool_prefix}nm"
+  if test -n "$ac_tool_prefix" && test "$build" = "$host"; then
+    lt_nm_to_check="$lt_nm_to_check nm"
+  fi
+  for lt_tmp_nm in $lt_nm_to_check; do
+    lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+    for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do
+      IFS="$lt_save_ifs"
+      test -z "$ac_dir" && ac_dir=.
+      tmp_nm="$ac_dir/$lt_tmp_nm"
+      if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then
+	# Check to see if the nm accepts a BSD-compat flag.
+	# Adding the `sed 1q' prevents false positives on HP-UX, which says:
+	#   nm: unknown option "B" ignored
+	# Tru64's nm complains that /dev/null is an invalid object file
+	case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in
+	*/dev/null* | *'Invalid file or object type'*)
+	  lt_cv_path_NM="$tmp_nm -B"
+	  break
+	  ;;
+	*)
+	  case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
+	  */dev/null*)
+	    lt_cv_path_NM="$tmp_nm -p"
+	    break
+	    ;;
+	  *)
+	    lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
+	    continue # so that we can try to find one that supports BSD flags
+	    ;;
+	  esac
+	  ;;
+	esac
+      fi
+    done
+    IFS="$lt_save_ifs"
+  done
+  : ${lt_cv_path_NM=no}
+fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5
+$as_echo "$lt_cv_path_NM" >&6; }
+if test "$lt_cv_path_NM" != "no"; then
+  NM="$lt_cv_path_NM"
+else
+  # Didn't find any BSD compatible name lister, look for dumpbin.
+  if test -n "$DUMPBIN"; then :
+    # Let the user override the test.
+  else
+    if test -n "$ac_tool_prefix"; then
+  for ac_prog in dumpbin "link -dump"
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_DUMPBIN+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$DUMPBIN"; then
+  ac_cv_prog_DUMPBIN="$DUMPBIN" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_DUMPBIN="$ac_tool_prefix$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+DUMPBIN=$ac_cv_prog_DUMPBIN
+if test -n "$DUMPBIN"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5
+$as_echo "$DUMPBIN" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+    test -n "$DUMPBIN" && break
+  done
+fi
+if test -z "$DUMPBIN"; then
+  ac_ct_DUMPBIN=$DUMPBIN
+  for ac_prog in dumpbin "link -dump"
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_ac_ct_DUMPBIN+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_DUMPBIN"; then
+  ac_cv_prog_ac_ct_DUMPBIN="$ac_ct_DUMPBIN" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_ac_ct_DUMPBIN="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_DUMPBIN=$ac_cv_prog_ac_ct_DUMPBIN
+if test -n "$ac_ct_DUMPBIN"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DUMPBIN" >&5
+$as_echo "$ac_ct_DUMPBIN" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$ac_ct_DUMPBIN" && break
+done
+
+  if test "x$ac_ct_DUMPBIN" = x; then
+    DUMPBIN=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    DUMPBIN=$ac_ct_DUMPBIN
+  fi
+fi
+
+    case `$DUMPBIN -symbols /dev/null 2>&1 | sed '1q'` in
+    *COFF*)
+      DUMPBIN="$DUMPBIN -symbols"
+      ;;
+    *)
+      DUMPBIN=:
+      ;;
+    esac
+  fi
+
+  if test "$DUMPBIN" != ":"; then
+    NM="$DUMPBIN"
+  fi
+fi
+test -z "$NM" && NM=nm
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface" >&5
+$as_echo_n "checking the name lister ($NM) interface... " >&6; }
+if test "${lt_cv_nm_interface+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_nm_interface="BSD nm"
+  echo "int some_variable = 0;" > conftest.$ac_ext
+  (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&5)
+  (eval "$ac_compile" 2>conftest.err)
+  cat conftest.err >&5
+  (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&5)
+  (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out)
+  cat conftest.err >&5
+  (eval echo "\"\$as_me:$LINENO: output\"" >&5)
+  cat conftest.out >&5
+  if $GREP 'External.*some_variable' conftest.out > /dev/null; then
+    lt_cv_nm_interface="MS dumpbin"
+  fi
+  rm -f conftest*
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5
+$as_echo "$lt_cv_nm_interface" >&6; }
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5
+$as_echo_n "checking whether ln -s works... " >&6; }
+LN_S=$as_ln_s
+if test "$LN_S" = "ln -s"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5
+$as_echo "no, using $LN_S" >&6; }
+fi
+
+# find the maximum length of command line arguments
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the maximum length of command line arguments" >&5
+$as_echo_n "checking the maximum length of command line arguments... " >&6; }
+if test "${lt_cv_sys_max_cmd_len+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+    i=0
+  teststring="ABCD"
+
+  case $build_os in
+  msdosdjgpp*)
+    # On DJGPP, this test can blow up pretty badly due to problems in libc
+    # (any single argument exceeding 2000 bytes causes a buffer overrun
+    # during glob expansion).  Even if it were fixed, the result of this
+    # check would be larger than it should be.
+    lt_cv_sys_max_cmd_len=12288;    # 12K is about right
+    ;;
+
+  gnu*)
+    # Under GNU Hurd, this test is not required because there is
+    # no limit to the length of command line arguments.
+    # Libtool will interpret -1 as no limit whatsoever
+    lt_cv_sys_max_cmd_len=-1;
+    ;;
+
+  cygwin* | mingw* | cegcc*)
+    # On Win9x/ME, this test blows up -- it succeeds, but takes
+    # about 5 minutes as the teststring grows exponentially.
+    # Worse, since 9x/ME are not pre-emptively multitasking,
+    # you end up with a "frozen" computer, even though with patience
+    # the test eventually succeeds (with a max line length of 256k).
+    # Instead, let's just punt: use the minimum linelength reported by
+    # all of the supported platforms: 8192 (on NT/2K/XP).
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  mint*)
+    # On MiNT this can take a long time and run out of memory.
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  amigaos*)
+    # On AmigaOS with pdksh, this test takes hours, literally.
+    # So we just punt and use a minimum line length of 8192.
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)
+    # This has been around since 386BSD, at least.  Likely further.
+    if test -x /sbin/sysctl; then
+      lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
+    elif test -x /usr/sbin/sysctl; then
+      lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
+    else
+      lt_cv_sys_max_cmd_len=65536	# usable default for all BSDs
+    fi
+    # And add a safety zone
+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
+    ;;
+
+  interix*)
+    # We know the value 262144 and hardcode it with a safety zone (like BSD)
+    lt_cv_sys_max_cmd_len=196608
+    ;;
+
+  osf*)
+    # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure
+    # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not
+    # nice to cause kernel panics so lets avoid the loop below.
+    # First set a reasonable default.
+    lt_cv_sys_max_cmd_len=16384
+    #
+    if test -x /sbin/sysconfig; then
+      case `/sbin/sysconfig -q proc exec_disable_arg_limit` in
+        *1*) lt_cv_sys_max_cmd_len=-1 ;;
+      esac
+    fi
+    ;;
+  sco3.2v5*)
+    lt_cv_sys_max_cmd_len=102400
+    ;;
+  sysv5* | sco5v6* | sysv4.2uw2*)
+    kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`
+    if test -n "$kargmax"; then
+      lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[	 ]//'`
+    else
+      lt_cv_sys_max_cmd_len=32768
+    fi
+    ;;
+  *)
+    lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null`
+    if test -n "$lt_cv_sys_max_cmd_len"; then
+      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
+      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
+    else
+      # Make teststring a little bigger before we do anything with it.
+      # a 1K string should be a reasonable start.
+      for i in 1 2 3 4 5 6 7 8 ; do
+        teststring=$teststring$teststring
+      done
+      SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
+      # If test is not a shell built-in, we'll probably end up computing a
+      # maximum length that is only half of the actual maximum length, but
+      # we can't tell.
+      while { test "X"`func_fallback_echo "$teststring$teststring" 2>/dev/null` \
+	         = "X$teststring$teststring"; } >/dev/null 2>&1 &&
+	      test $i != 17 # 1/2 MB should be enough
+      do
+        i=`expr $i + 1`
+        teststring=$teststring$teststring
+      done
+      # Only check the string length outside the loop.
+      lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1`
+      teststring=
+      # Add a significant safety factor because C++ compilers can tack on
+      # massive amounts of additional arguments before passing them to the
+      # linker.  It appears as though 1/2 is a usable value.
+      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`
+    fi
+    ;;
+  esac
+
+fi
+
+if test -n $lt_cv_sys_max_cmd_len ; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5
+$as_echo "$lt_cv_sys_max_cmd_len" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: none" >&5
+$as_echo "none" >&6; }
+fi
+max_cmd_len=$lt_cv_sys_max_cmd_len
+
+
+
+
+
+
+: ${CP="cp -f"}
+: ${MV="mv -f"}
+: ${RM="rm -f"}
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the shell understands some XSI constructs" >&5
+$as_echo_n "checking whether the shell understands some XSI constructs... " >&6; }
+# Try some XSI features
+xsi_shell=no
+( _lt_dummy="a/b/c"
+  test "${_lt_dummy##*/},${_lt_dummy%/*},"${_lt_dummy%"$_lt_dummy"}, \
+      = c,a/b,, \
+    && eval 'test $(( 1 + 1 )) -eq 2 \
+    && test "${#_lt_dummy}" -eq 5' ) >/dev/null 2>&1 \
+  && xsi_shell=yes
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $xsi_shell" >&5
+$as_echo "$xsi_shell" >&6; }
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the shell understands \"+=\"" >&5
+$as_echo_n "checking whether the shell understands \"+=\"... " >&6; }
+lt_shell_append=no
+( foo=bar; set foo baz; eval "$1+=\$2" && test "$foo" = barbaz ) \
+    >/dev/null 2>&1 \
+  && lt_shell_append=yes
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_shell_append" >&5
+$as_echo "$lt_shell_append" >&6; }
+
+
+if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+  lt_unset=unset
+else
+  lt_unset=false
+fi
+
+
+
+
+
+# test EBCDIC or ASCII
+case `echo X|tr X '\101'` in
+ A) # ASCII based system
+    # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
+  lt_SP2NL='tr \040 \012'
+  lt_NL2SP='tr \015\012 \040\040'
+  ;;
+ *) # EBCDIC based system
+  lt_SP2NL='tr \100 \n'
+  lt_NL2SP='tr \r\n \100\100'
+  ;;
+esac
+
+
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LD option to reload object files" >&5
+$as_echo_n "checking for $LD option to reload object files... " >&6; }
+if test "${lt_cv_ld_reload_flag+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_ld_reload_flag='-r'
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_reload_flag" >&5
+$as_echo "$lt_cv_ld_reload_flag" >&6; }
+reload_flag=$lt_cv_ld_reload_flag
+case $reload_flag in
+"" | " "*) ;;
+*) reload_flag=" $reload_flag" ;;
+esac
+reload_cmds='$LD$reload_flag -o $output$reload_objs'
+case $host_os in
+  darwin*)
+    if test "$GCC" = yes; then
+      reload_cmds='$LTCC $LTCFLAGS -nostdlib ${wl}-r -o $output$reload_objs'
+    else
+      reload_cmds='$LD$reload_flag -o $output$reload_objs'
+    fi
+    ;;
+esac
+
+
+
+
+
+
+
+
+
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args.
+set dummy ${ac_tool_prefix}objdump; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_OBJDUMP+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$OBJDUMP"; then
+  ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+OBJDUMP=$ac_cv_prog_OBJDUMP
+if test -n "$OBJDUMP"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
+$as_echo "$OBJDUMP" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_OBJDUMP"; then
+  ac_ct_OBJDUMP=$OBJDUMP
+  # Extract the first word of "objdump", so it can be a program name with args.
+set dummy objdump; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_ac_ct_OBJDUMP+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_OBJDUMP"; then
+  ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_ac_ct_OBJDUMP="objdump"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
+if test -n "$ac_ct_OBJDUMP"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
+$as_echo "$ac_ct_OBJDUMP" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_OBJDUMP" = x; then
+    OBJDUMP="false"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    OBJDUMP=$ac_ct_OBJDUMP
+  fi
+else
+  OBJDUMP="$ac_cv_prog_OBJDUMP"
+fi
+
+test -z "$OBJDUMP" && OBJDUMP=objdump
+
+
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to recognize dependent libraries" >&5
+$as_echo_n "checking how to recognize dependent libraries... " >&6; }
+if test "${lt_cv_deplibs_check_method+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_file_magic_cmd='$MAGIC_CMD'
+lt_cv_file_magic_test_file=
+lt_cv_deplibs_check_method='unknown'
+# Need to set the preceding variable on all platforms that support
+# interlibrary dependencies.
+# 'none' -- dependencies not supported.
+# `unknown' -- same as none, but documents that we really don't know.
+# 'pass_all' -- all dependencies passed with no checks.
+# 'test_compile' -- check by making test program.
+# 'file_magic [[regex]]' -- check by looking for files in library path
+# which responds to the $file_magic_cmd with a given extended regex.
+# If you have `file' or equivalent on your system and you're not sure
+# whether `pass_all' will *always* work, you probably want this one.
+
+case $host_os in
+aix[4-9]*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+beos*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+bsdi[45]*)
+  lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
+  lt_cv_file_magic_cmd='/usr/bin/file -L'
+  lt_cv_file_magic_test_file=/shlib/libc.so
+  ;;
+
+cygwin*)
+  # func_win32_libid is a shell function defined in ltmain.sh
+  lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
+  lt_cv_file_magic_cmd='func_win32_libid'
+  ;;
+
+mingw* | pw32*)
+  # Base MSYS/MinGW do not provide the 'file' command needed by
+  # func_win32_libid shell function, so use a weaker test based on 'objdump',
+  # unless we find 'file', for example because we are cross-compiling.
+  # func_win32_libid assumes BSD nm, so disallow it if using MS dumpbin.
+  if ( test "$lt_cv_nm_interface" = "BSD nm" && file / ) >/dev/null 2>&1; then
+    lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
+    lt_cv_file_magic_cmd='func_win32_libid'
+  else
+    lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
+    lt_cv_file_magic_cmd='$OBJDUMP -f'
+  fi
+  ;;
+
+cegcc*)
+  # use the weaker test based on 'objdump'. See mingw*.
+  lt_cv_deplibs_check_method='file_magic file format pe-arm-.*little(.*architecture: arm)?'
+  lt_cv_file_magic_cmd='$OBJDUMP -f'
+  ;;
+
+darwin* | rhapsody*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+freebsd* | dragonfly*)
+  if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
+    case $host_cpu in
+    i*86 )
+      # Not sure whether the presence of OpenBSD here was a mistake.
+      # Let's accept both of them until this is cleared up.
+      lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[3-9]86 (compact )?demand paged shared library'
+      lt_cv_file_magic_cmd=/usr/bin/file
+      lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
+      ;;
+    esac
+  else
+    lt_cv_deplibs_check_method=pass_all
+  fi
+  ;;
+
+gnu*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+haiku*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+hpux10.20* | hpux11*)
+  lt_cv_file_magic_cmd=/usr/bin/file
+  case $host_cpu in
+  ia64*)
+    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64'
+    lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
+    ;;
+  hppa*64*)
+    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF[ -][0-9][0-9])(-bit)?( [LM]SB)? shared object( file)?[, -]* PA-RISC [0-9]\.[0-9]'
+    lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl
+    ;;
+  *)
+    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9]\.[0-9]) shared library'
+    lt_cv_file_magic_test_file=/usr/lib/libc.sl
+    ;;
+  esac
+  ;;
+
+interix[3-9]*)
+  # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here
+  lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|\.a)$'
+  ;;
+
+irix5* | irix6* | nonstopux*)
+  case $LD in
+  *-32|*"-32 ") libmagic=32-bit;;
+  *-n32|*"-n32 ") libmagic=N32;;
+  *-64|*"-64 ") libmagic=64-bit;;
+  *) libmagic=never-match;;
+  esac
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+# This must be Linux ELF.
+linux* | k*bsd*-gnu | kopensolaris*-gnu)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+netbsd*)
+  if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
+    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$'
+  else
+    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|_pic\.a)$'
+  fi
+  ;;
+
+newos6*)
+  lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)'
+  lt_cv_file_magic_cmd=/usr/bin/file
+  lt_cv_file_magic_test_file=/usr/lib/libnls.so
+  ;;
+
+*nto* | *qnx*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+openbsd*)
+  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|\.so|_pic\.a)$'
+  else
+    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$'
+  fi
+  ;;
+
+osf3* | osf4* | osf5*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+rdos*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+solaris*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+sysv4 | sysv4.3*)
+  case $host_vendor in
+  motorola)
+    lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]'
+    lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
+    ;;
+  ncr)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  sequent)
+    lt_cv_file_magic_cmd='/bin/file'
+    lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )'
+    ;;
+  sni)
+    lt_cv_file_magic_cmd='/bin/file'
+    lt_cv_deplibs_check_method="file_magic ELF [0-9][0-9]*-bit [LM]SB dynamic lib"
+    lt_cv_file_magic_test_file=/lib/libc.so
+    ;;
+  siemens)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  pc)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  esac
+  ;;
+
+tpf*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+esac
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_deplibs_check_method" >&5
+$as_echo "$lt_cv_deplibs_check_method" >&6; }
+file_magic_cmd=$lt_cv_file_magic_cmd
+deplibs_check_method=$lt_cv_deplibs_check_method
+test -z "$deplibs_check_method" && deplibs_check_method=unknown
+
+
+
+
+
+
+
+
+
+
+
+
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
+set dummy ${ac_tool_prefix}ar; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_AR+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$AR"; then
+  ac_cv_prog_AR="$AR" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_AR="${ac_tool_prefix}ar"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+AR=$ac_cv_prog_AR
+if test -n "$AR"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
+$as_echo "$AR" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_AR"; then
+  ac_ct_AR=$AR
+  # Extract the first word of "ar", so it can be a program name with args.
+set dummy ar; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_ac_ct_AR+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_AR"; then
+  ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_ac_ct_AR="ar"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_AR=$ac_cv_prog_ac_ct_AR
+if test -n "$ac_ct_AR"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
+$as_echo "$ac_ct_AR" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_AR" = x; then
+    AR="false"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    AR=$ac_ct_AR
+  fi
+else
+  AR="$ac_cv_prog_AR"
+fi
+
+test -z "$AR" && AR=ar
+test -z "$AR_FLAGS" && AR_FLAGS=cru
+
+
+
+
+
+
+
+
+
+
+
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
+set dummy ${ac_tool_prefix}strip; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_STRIP+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$STRIP"; then
+  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+STRIP=$ac_cv_prog_STRIP
+if test -n "$STRIP"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
+$as_echo "$STRIP" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_STRIP"; then
+  ac_ct_STRIP=$STRIP
+  # Extract the first word of "strip", so it can be a program name with args.
+set dummy strip; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_STRIP"; then
+  ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_ac_ct_STRIP="strip"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+if test -n "$ac_ct_STRIP"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
+$as_echo "$ac_ct_STRIP" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_STRIP" = x; then
+    STRIP=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    STRIP=$ac_ct_STRIP
+  fi
+else
+  STRIP="$ac_cv_prog_STRIP"
+fi
+
+test -z "$STRIP" && STRIP=:
+
+
+
+
+
+
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
+set dummy ${ac_tool_prefix}ranlib; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_RANLIB+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$RANLIB"; then
+  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+RANLIB=$ac_cv_prog_RANLIB
+if test -n "$RANLIB"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5
+$as_echo "$RANLIB" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_RANLIB"; then
+  ac_ct_RANLIB=$RANLIB
+  # Extract the first word of "ranlib", so it can be a program name with args.
+set dummy ranlib; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_RANLIB"; then
+  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_ac_ct_RANLIB="ranlib"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
+if test -n "$ac_ct_RANLIB"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5
+$as_echo "$ac_ct_RANLIB" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_RANLIB" = x; then
+    RANLIB=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    RANLIB=$ac_ct_RANLIB
+  fi
+else
+  RANLIB="$ac_cv_prog_RANLIB"
+fi
+
+test -z "$RANLIB" && RANLIB=:
+
+
+
+
+
+
+# Determine commands to create old-style static archives.
+old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs'
+old_postinstall_cmds='chmod 644 $oldlib'
+old_postuninstall_cmds=
+
+if test -n "$RANLIB"; then
+  case $host_os in
+  openbsd*)
+    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$oldlib"
+    ;;
+  *)
+    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$oldlib"
+    ;;
+  esac
+  old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib"
+fi
+
+case $host_os in
+  darwin*)
+    lock_old_archive_extraction=yes ;;
+  *)
+    lock_old_archive_extraction=no ;;
+esac
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# If no C compiler was specified, use CC.
+LTCC=${LTCC-"$CC"}
+
+# If no C compiler flags were specified, use CFLAGS.
+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
+
+# Allow CC to be a program name with arguments.
+compiler=$CC
+
+
+# Check for command to grab the raw symbol name followed by C symbol from nm.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking command to parse $NM output from $compiler object" >&5
+$as_echo_n "checking command to parse $NM output from $compiler object... " >&6; }
+if test "${lt_cv_sys_global_symbol_pipe+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+
+# These are sane defaults that work on at least a few old systems.
+# [They come from Ultrix.  What could be older than Ultrix?!! ;)]
+
+# Character class describing NM global symbol codes.
+symcode='[BCDEGRST]'
+
+# Regexp to match symbols that can be accessed directly from C.
+sympat='\([_A-Za-z][_A-Za-z0-9]*\)'
+
+# Define system-specific variables.
+case $host_os in
+aix*)
+  symcode='[BCDT]'
+  ;;
+cygwin* | mingw* | pw32* | cegcc*)
+  symcode='[ABCDGISTW]'
+  ;;
+hpux*)
+  if test "$host_cpu" = ia64; then
+    symcode='[ABCDEGRST]'
+  fi
+  ;;
+irix* | nonstopux*)
+  symcode='[BCDEGRST]'
+  ;;
+osf*)
+  symcode='[BCDEGQRST]'
+  ;;
+solaris*)
+  symcode='[BDRT]'
+  ;;
+sco3.2v5*)
+  symcode='[DT]'
+  ;;
+sysv4.2uw2*)
+  symcode='[DT]'
+  ;;
+sysv5* | sco5v6* | unixware* | OpenUNIX*)
+  symcode='[ABDT]'
+  ;;
+sysv4)
+  symcode='[DFNSTU]'
+  ;;
+esac
+
+# If we're using GNU nm, then use its standard symbol codes.
+case `$NM -V 2>&1` in
+*GNU* | *'with BFD'*)
+  symcode='[ABCDGIRSTW]' ;;
+esac
+
+# Transform an extracted symbol line into a proper C declaration.
+# Some systems (esp. on ia64) link data and code symbols differently,
+# so use this general approach.
+lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
+
+# Transform an extracted symbol line into symbol name and symbol address
+lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\) $/  {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/  {\"\2\", (void *) \&\2},/p'"
+lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \([^ ]*\) $/  {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([^ ]*\) \(lib[^ ]*\)$/  {\"\2\", (void *) \&\2},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/  {\"lib\2\", (void *) \&\2},/p'"
+
+# Handle CRLF in mingw tool chain
+opt_cr=
+case $build_os in
+mingw*)
+  opt_cr=`$ECHO 'x\{0,1\}' | tr x '\015'` # option cr in regexp
+  ;;
+esac
+
+# Try without a prefix underscore, then with it.
+for ac_symprfx in "" "_"; do
+
+  # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol.
+  symxfrm="\\1 $ac_symprfx\\2 \\2"
+
+  # Write the raw and C identifiers.
+  if test "$lt_cv_nm_interface" = "MS dumpbin"; then
+    # Fake it for dumpbin and say T for any non-static function
+    # and D for any global variable.
+    # Also find C++ and __fastcall symbols from MSVC++,
+    # which start with @ or ?.
+    lt_cv_sys_global_symbol_pipe="$AWK '"\
+"     {last_section=section; section=\$ 3};"\
+"     /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\
+"     \$ 0!~/External *\|/{next};"\
+"     / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\
+"     {if(hide[section]) next};"\
+"     {f=0}; \$ 0~/\(\).*\|/{f=1}; {printf f ? \"T \" : \"D \"};"\
+"     {split(\$ 0, a, /\||\r/); split(a[2], s)};"\
+"     s[1]~/^[@?]/{print s[1], s[1]; next};"\
+"     s[1]~prfx {split(s[1],t,\"@\"); print t[1], substr(t[1],length(prfx))}"\
+"     ' prfx=^$ac_symprfx"
+  else
+    lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[	 ]\($symcode$symcode*\)[	 ][	 ]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
+  fi
+
+  # Check to see that the pipe works correctly.
+  pipe_works=no
+
+  rm -f conftest*
+  cat > conftest.$ac_ext <<_LT_EOF
+#ifdef __cplusplus
+extern "C" {
+#endif
+char nm_test_var;
+void nm_test_func(void);
+void nm_test_func(void){}
+#ifdef __cplusplus
+}
+#endif
+int main(){nm_test_var='a';nm_test_func();return(0);}
+_LT_EOF
+
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+    # Now try to grab the symbols.
+    nlist=conftest.nm
+    if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist\""; } >&5
+  (eval $NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && test -s "$nlist"; then
+      # Try sorting and uniquifying the output.
+      if sort "$nlist" | uniq > "$nlist"T; then
+	mv -f "$nlist"T "$nlist"
+      else
+	rm -f "$nlist"T
+      fi
+
+      # Make sure that we snagged all the symbols we need.
+      if $GREP ' nm_test_var$' "$nlist" >/dev/null; then
+	if $GREP ' nm_test_func$' "$nlist" >/dev/null; then
+	  cat <<_LT_EOF > conftest.$ac_ext
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+_LT_EOF
+	  # Now generate the symbol file.
+	  eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext'
+
+	  cat <<_LT_EOF >> conftest.$ac_ext
+
+/* The mapping between symbol names and symbols.  */
+const struct {
+  const char *name;
+  void       *address;
+}
+lt__PROGRAM__LTX_preloaded_symbols[] =
+{
+  { "@PROGRAM@", (void *) 0 },
+_LT_EOF
+	  $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/  {\"\2\", (void *) \&\2},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext
+	  cat <<\_LT_EOF >> conftest.$ac_ext
+  {0, (void *) 0}
+};
+
+/* This works around a problem in FreeBSD linker */
+#ifdef FREEBSD_WORKAROUND
+static const void *lt_preloaded_setup() {
+  return lt__PROGRAM__LTX_preloaded_symbols;
+}
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+_LT_EOF
+	  # Now try linking the two files.
+	  mv conftest.$ac_objext conftstm.$ac_objext
+	  lt_save_LIBS="$LIBS"
+	  lt_save_CFLAGS="$CFLAGS"
+	  LIBS="conftstm.$ac_objext"
+	  CFLAGS="$CFLAGS$lt_prog_compiler_no_builtin_flag"
+	  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
+  (eval $ac_link) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && test -s conftest${ac_exeext}; then
+	    pipe_works=yes
+	  fi
+	  LIBS="$lt_save_LIBS"
+	  CFLAGS="$lt_save_CFLAGS"
+	else
+	  echo "cannot find nm_test_func in $nlist" >&5
+	fi
+      else
+	echo "cannot find nm_test_var in $nlist" >&5
+      fi
+    else
+      echo "cannot run $lt_cv_sys_global_symbol_pipe" >&5
+    fi
+  else
+    echo "$progname: failed program was:" >&5
+    cat conftest.$ac_ext >&5
+  fi
+  rm -rf conftest* conftst*
+
+  # Do not use the global_symbol_pipe unless it works.
+  if test "$pipe_works" = yes; then
+    break
+  else
+    lt_cv_sys_global_symbol_pipe=
+  fi
+done
+
+fi
+
+if test -z "$lt_cv_sys_global_symbol_pipe"; then
+  lt_cv_sys_global_symbol_to_cdecl=
+fi
+if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
+$as_echo "failed" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+$as_echo "ok" >&6; }
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# Check whether --enable-libtool-lock was given.
+if test "${enable_libtool_lock+set}" = set; then :
+  enableval=$enable_libtool_lock;
+fi
+
+test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes
+
+# Some flags need to be propagated to the compiler or linker for good
+# libtool support.
+case $host in
+ia64-*-hpux*)
+  # Find out which ABI we are using.
+  echo 'int i;' > conftest.$ac_ext
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+    case `/usr/bin/file conftest.$ac_objext` in
+      *ELF-32*)
+	HPUX_IA64_MODE="32"
+	;;
+      *ELF-64*)
+	HPUX_IA64_MODE="64"
+	;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+*-*-irix6*)
+  # Find out which ABI we are using.
+  echo '#line '$LINENO' "configure"' > conftest.$ac_ext
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+    if test "$lt_cv_prog_gnu_ld" = yes; then
+      case `/usr/bin/file conftest.$ac_objext` in
+	*32-bit*)
+	  LD="${LD-ld} -melf32bsmip"
+	  ;;
+	*N32*)
+	  LD="${LD-ld} -melf32bmipn32"
+	  ;;
+	*64-bit*)
+	  LD="${LD-ld} -melf64bmip"
+	;;
+      esac
+    else
+      case `/usr/bin/file conftest.$ac_objext` in
+	*32-bit*)
+	  LD="${LD-ld} -32"
+	  ;;
+	*N32*)
+	  LD="${LD-ld} -n32"
+	  ;;
+	*64-bit*)
+	  LD="${LD-ld} -64"
+	  ;;
+      esac
+    fi
+  fi
+  rm -rf conftest*
+  ;;
+
+x86_64-*kfreebsd*-gnu|x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*| \
+s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
+  # Find out which ABI we are using.
+  echo 'int i;' > conftest.$ac_ext
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+    case `/usr/bin/file conftest.o` in
+      *32-bit*)
+	case $host in
+	  x86_64-*kfreebsd*-gnu)
+	    LD="${LD-ld} -m elf_i386_fbsd"
+	    ;;
+	  x86_64-*linux*)
+	    case `/usr/bin/file conftest.o` in
+	      *x86-64*)
+		LD="${LD-ld} -m elf32_x86_64"
+		;;
+	      *)
+		LD="${LD-ld} -m elf_i386"
+		;;
+	    esac
+	    ;;
+	  ppc64-*linux*|powerpc64-*linux*)
+	    LD="${LD-ld} -m elf32ppclinux"
+	    ;;
+	  s390x-*linux*)
+	    LD="${LD-ld} -m elf_s390"
+	    ;;
+	  sparc64-*linux*)
+	    LD="${LD-ld} -m elf32_sparc"
+	    ;;
+	esac
+	;;
+      *64-bit*)
+	case $host in
+	  x86_64-*kfreebsd*-gnu)
+	    LD="${LD-ld} -m elf_x86_64_fbsd"
+	    ;;
+	  x86_64-*linux*)
+	    LD="${LD-ld} -m elf_x86_64"
+	    ;;
+	  ppc*-*linux*|powerpc*-*linux*)
+	    LD="${LD-ld} -m elf64ppc"
+	    ;;
+	  s390*-*linux*|s390*-*tpf*)
+	    LD="${LD-ld} -m elf64_s390"
+	    ;;
+	  sparc*-*linux*)
+	    LD="${LD-ld} -m elf64_sparc"
+	    ;;
+	esac
+	;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+
+*-*-sco3.2v5*)
+  # On SCO OpenServer 5, we need -belf to get full-featured binaries.
+  SAVE_CFLAGS="$CFLAGS"
+  CFLAGS="$CFLAGS -belf"
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler needs -belf" >&5
+$as_echo_n "checking whether the C compiler needs -belf... " >&6; }
+if test "${lt_cv_cc_needs_belf+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  lt_cv_cc_needs_belf=yes
+else
+  lt_cv_cc_needs_belf=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+     ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf" >&5
+$as_echo "$lt_cv_cc_needs_belf" >&6; }
+  if test x"$lt_cv_cc_needs_belf" != x"yes"; then
+    # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
+    CFLAGS="$SAVE_CFLAGS"
+  fi
+  ;;
+sparc*-*solaris*)
+  # Find out which ABI we are using.
+  echo 'int i;' > conftest.$ac_ext
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+    case `/usr/bin/file conftest.o` in
+    *64-bit*)
+      case $lt_cv_prog_gnu_ld in
+      yes*) LD="${LD-ld} -m elf64_sparc" ;;
+      *)
+	if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then
+	  LD="${LD-ld} -64"
+	fi
+	;;
+      esac
+      ;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+esac
+
+need_locks="$enable_libtool_lock"
+
+
+  case $host_os in
+    rhapsody* | darwin*)
+    if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}dsymutil", so it can be a program name with args.
+set dummy ${ac_tool_prefix}dsymutil; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_DSYMUTIL+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$DSYMUTIL"; then
+  ac_cv_prog_DSYMUTIL="$DSYMUTIL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_DSYMUTIL="${ac_tool_prefix}dsymutil"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+DSYMUTIL=$ac_cv_prog_DSYMUTIL
+if test -n "$DSYMUTIL"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
+$as_echo "$DSYMUTIL" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_DSYMUTIL"; then
+  ac_ct_DSYMUTIL=$DSYMUTIL
+  # Extract the first word of "dsymutil", so it can be a program name with args.
+set dummy dsymutil; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_ac_ct_DSYMUTIL+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_DSYMUTIL"; then
+  ac_cv_prog_ac_ct_DSYMUTIL="$ac_ct_DSYMUTIL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_ac_ct_DSYMUTIL="dsymutil"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_DSYMUTIL=$ac_cv_prog_ac_ct_DSYMUTIL
+if test -n "$ac_ct_DSYMUTIL"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DSYMUTIL" >&5
+$as_echo "$ac_ct_DSYMUTIL" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_DSYMUTIL" = x; then
+    DSYMUTIL=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    DSYMUTIL=$ac_ct_DSYMUTIL
+  fi
+else
+  DSYMUTIL="$ac_cv_prog_DSYMUTIL"
+fi
+
+    if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}nmedit", so it can be a program name with args.
+set dummy ${ac_tool_prefix}nmedit; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_NMEDIT+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$NMEDIT"; then
+  ac_cv_prog_NMEDIT="$NMEDIT" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_NMEDIT="${ac_tool_prefix}nmedit"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+NMEDIT=$ac_cv_prog_NMEDIT
+if test -n "$NMEDIT"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NMEDIT" >&5
+$as_echo "$NMEDIT" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_NMEDIT"; then
+  ac_ct_NMEDIT=$NMEDIT
+  # Extract the first word of "nmedit", so it can be a program name with args.
+set dummy nmedit; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_ac_ct_NMEDIT+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_NMEDIT"; then
+  ac_cv_prog_ac_ct_NMEDIT="$ac_ct_NMEDIT" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_ac_ct_NMEDIT="nmedit"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_NMEDIT=$ac_cv_prog_ac_ct_NMEDIT
+if test -n "$ac_ct_NMEDIT"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NMEDIT" >&5
+$as_echo "$ac_ct_NMEDIT" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_NMEDIT" = x; then
+    NMEDIT=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    NMEDIT=$ac_ct_NMEDIT
+  fi
+else
+  NMEDIT="$ac_cv_prog_NMEDIT"
+fi
+
+    if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}lipo", so it can be a program name with args.
+set dummy ${ac_tool_prefix}lipo; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_LIPO+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$LIPO"; then
+  ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_LIPO="${ac_tool_prefix}lipo"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+LIPO=$ac_cv_prog_LIPO
+if test -n "$LIPO"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
+$as_echo "$LIPO" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_LIPO"; then
+  ac_ct_LIPO=$LIPO
+  # Extract the first word of "lipo", so it can be a program name with args.
+set dummy lipo; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_ac_ct_LIPO+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_LIPO"; then
+  ac_cv_prog_ac_ct_LIPO="$ac_ct_LIPO" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_ac_ct_LIPO="lipo"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_LIPO=$ac_cv_prog_ac_ct_LIPO
+if test -n "$ac_ct_LIPO"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_LIPO" >&5
+$as_echo "$ac_ct_LIPO" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_LIPO" = x; then
+    LIPO=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    LIPO=$ac_ct_LIPO
+  fi
+else
+  LIPO="$ac_cv_prog_LIPO"
+fi
+
+    if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}otool", so it can be a program name with args.
+set dummy ${ac_tool_prefix}otool; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_OTOOL+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$OTOOL"; then
+  ac_cv_prog_OTOOL="$OTOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_OTOOL="${ac_tool_prefix}otool"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+OTOOL=$ac_cv_prog_OTOOL
+if test -n "$OTOOL"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
+$as_echo "$OTOOL" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_OTOOL"; then
+  ac_ct_OTOOL=$OTOOL
+  # Extract the first word of "otool", so it can be a program name with args.
+set dummy otool; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_ac_ct_OTOOL+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_OTOOL"; then
+  ac_cv_prog_ac_ct_OTOOL="$ac_ct_OTOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_ac_ct_OTOOL="otool"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_OTOOL=$ac_cv_prog_ac_ct_OTOOL
+if test -n "$ac_ct_OTOOL"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL" >&5
+$as_echo "$ac_ct_OTOOL" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_OTOOL" = x; then
+    OTOOL=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    OTOOL=$ac_ct_OTOOL
+  fi
+else
+  OTOOL="$ac_cv_prog_OTOOL"
+fi
+
+    if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}otool64", so it can be a program name with args.
+set dummy ${ac_tool_prefix}otool64; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_OTOOL64+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$OTOOL64"; then
+  ac_cv_prog_OTOOL64="$OTOOL64" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_OTOOL64="${ac_tool_prefix}otool64"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+OTOOL64=$ac_cv_prog_OTOOL64
+if test -n "$OTOOL64"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL64" >&5
+$as_echo "$OTOOL64" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_OTOOL64"; then
+  ac_ct_OTOOL64=$OTOOL64
+  # Extract the first word of "otool64", so it can be a program name with args.
+set dummy otool64; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if test "${ac_cv_prog_ac_ct_OTOOL64+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_OTOOL64"; then
+  ac_cv_prog_ac_ct_OTOOL64="$ac_ct_OTOOL64" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_ac_ct_OTOOL64="otool64"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_OTOOL64=$ac_cv_prog_ac_ct_OTOOL64
+if test -n "$ac_ct_OTOOL64"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL64" >&5
+$as_echo "$ac_ct_OTOOL64" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_OTOOL64" = x; then
+    OTOOL64=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    OTOOL64=$ac_ct_OTOOL64
+  fi
+else
+  OTOOL64="$ac_cv_prog_OTOOL64"
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -single_module linker flag" >&5
+$as_echo_n "checking for -single_module linker flag... " >&6; }
+if test "${lt_cv_apple_cc_single_mod+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_apple_cc_single_mod=no
+      if test -z "${LT_MULTI_MODULE}"; then
+	# By default we will add the -single_module flag. You can override
+	# by either setting the environment variable LT_MULTI_MODULE
+	# non-empty at configure time, or by adding -multi_module to the
+	# link flags.
+	rm -rf libconftest.dylib*
+	echo "int foo(void){return 1;}" > conftest.c
+	echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
+-dynamiclib -Wl,-single_module conftest.c" >&5
+	$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
+	  -dynamiclib -Wl,-single_module conftest.c 2>conftest.err
+        _lt_result=$?
+	if test -f libconftest.dylib && test ! -s conftest.err && test $_lt_result = 0; then
+	  lt_cv_apple_cc_single_mod=yes
+	else
+	  cat conftest.err >&5
+	fi
+	rm -rf libconftest.dylib*
+	rm -f conftest.*
+      fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_apple_cc_single_mod" >&5
+$as_echo "$lt_cv_apple_cc_single_mod" >&6; }
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -exported_symbols_list linker flag" >&5
+$as_echo_n "checking for -exported_symbols_list linker flag... " >&6; }
+if test "${lt_cv_ld_exported_symbols_list+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_ld_exported_symbols_list=no
+      save_LDFLAGS=$LDFLAGS
+      echo "_main" > conftest.sym
+      LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym"
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  lt_cv_ld_exported_symbols_list=yes
+else
+  lt_cv_ld_exported_symbols_list=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+	LDFLAGS="$save_LDFLAGS"
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_exported_symbols_list" >&5
+$as_echo "$lt_cv_ld_exported_symbols_list" >&6; }
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -force_load linker flag" >&5
+$as_echo_n "checking for -force_load linker flag... " >&6; }
+if test "${lt_cv_ld_force_load+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_ld_force_load=no
+      cat > conftest.c << _LT_EOF
+int forced_loaded() { return 2;}
+_LT_EOF
+      echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&5
+      $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&5
+      echo "$AR cru libconftest.a conftest.o" >&5
+      $AR cru libconftest.a conftest.o 2>&5
+      cat > conftest.c << _LT_EOF
+int main() { return 0;}
+_LT_EOF
+      echo "$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a" >&5
+      $LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err
+      _lt_result=$?
+      if test -f conftest && test ! -s conftest.err && test $_lt_result = 0 && $GREP forced_load conftest 2>&1 >/dev/null; then
+	lt_cv_ld_force_load=yes
+      else
+	cat conftest.err >&5
+      fi
+        rm -f conftest.err libconftest.a conftest conftest.c
+        rm -rf conftest.dSYM
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_force_load" >&5
+$as_echo "$lt_cv_ld_force_load" >&6; }
+    case $host_os in
+    rhapsody* | darwin1.[012])
+      _lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;;
+    darwin1.*)
+      _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;
+    darwin*) # darwin 5.x on
+      # if running on 10.5 or later, the deployment target defaults
+      # to the OS version, if on x86, and 10.4, the deployment
+      # target defaults to 10.4. Don't you love it?
+      case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in
+	10.0,*86*-darwin8*|10.0,*-darwin[91]*)
+	  _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;
+	10.[012]*)
+	  _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;
+	10.*)
+	  _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;
+      esac
+    ;;
+  esac
+    if test "$lt_cv_apple_cc_single_mod" = "yes"; then
+      _lt_dar_single_mod='$single_module'
+    fi
+    if test "$lt_cv_ld_exported_symbols_list" = "yes"; then
+      _lt_dar_export_syms=' ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym'
+    else
+      _lt_dar_export_syms='~$NMEDIT -s $output_objdir/${libname}-symbols.expsym ${lib}'
+    fi
+    if test "$DSYMUTIL" != ":" && test "$lt_cv_ld_force_load" = "no"; then
+      _lt_dsymutil='~$DSYMUTIL $lib || :'
+    else
+      _lt_dsymutil=
+    fi
+    ;;
+  esac
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
+$as_echo_n "checking how to run the C preprocessor... " >&6; }
+# On Suns, sometimes $CPP names a directory.
+if test -n "$CPP" && test -d "$CPP"; then
+  CPP=
+fi
+if test -z "$CPP"; then
+  if test "${ac_cv_prog_CPP+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+      # Double quotes because CPP needs to be expanded
+    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
+    do
+      ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+  break
+fi
+
+    done
+    ac_cv_prog_CPP=$CPP
+
+fi
+  CPP=$ac_cv_prog_CPP
+else
+  ac_cv_prog_CPP=$CPP
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
+$as_echo "$CPP" >&6; }
+ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+
+else
+  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error "C preprocessor \"$CPP\" fails sanity check
+See \`config.log' for more details." "$LINENO" 5; }
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
+$as_echo_n "checking for ANSI C header files... " >&6; }
+if test "${ac_cv_header_stdc+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <float.h>
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_header_stdc=yes
+else
+  ac_cv_header_stdc=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+
+if test $ac_cv_header_stdc = yes; then
+  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <string.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "memchr" >/dev/null 2>&1; then :
+
+else
+  ac_cv_header_stdc=no
+fi
+rm -f conftest*
+
+fi
+
+if test $ac_cv_header_stdc = yes; then
+  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdlib.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "free" >/dev/null 2>&1; then :
+
+else
+  ac_cv_header_stdc=no
+fi
+rm -f conftest*
+
+fi
+
+if test $ac_cv_header_stdc = yes; then
+  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
+  if test "$cross_compiling" = yes; then :
+  :
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ctype.h>
+#include <stdlib.h>
+#if ((' ' & 0x0FF) == 0x020)
+# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
+# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
+#else
+# define ISLOWER(c) \
+		   (('a' <= (c) && (c) <= 'i') \
+		     || ('j' <= (c) && (c) <= 'r') \
+		     || ('s' <= (c) && (c) <= 'z'))
+# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
+#endif
+
+#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
+int
+main ()
+{
+  int i;
+  for (i = 0; i < 256; i++)
+    if (XOR (islower (i), ISLOWER (i))
+	|| toupper (i) != TOUPPER (i))
+      return 2;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+
+else
+  ac_cv_header_stdc=no
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
+$as_echo "$ac_cv_header_stdc" >&6; }
+if test $ac_cv_header_stdc = yes; then
+
+$as_echo "#define STDC_HEADERS 1" >>confdefs.h
+
+fi
+
+# On IRIX 5.3, sys/types and inttypes.h are conflicting.
+for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
+		  inttypes.h stdint.h unistd.h
+do :
+  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
+ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
+"
+eval as_val=\$$as_ac_Header
+   if test "x$as_val" = x""yes; then :
+  cat >>confdefs.h <<_ACEOF
+#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+
+done
+
+
+for ac_header in dlfcn.h
+do :
+  ac_fn_c_check_header_compile "$LINENO" "dlfcn.h" "ac_cv_header_dlfcn_h" "$ac_includes_default
+"
+if test "x$ac_cv_header_dlfcn_h" = x""yes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_DLFCN_H 1
+_ACEOF
+
+fi
+
+done
+
+
+
+
+
+# Set options
+
+
+
+        enable_dlopen=no
+
+
+  enable_win32_dll=no
+
+
+            # Check whether --enable-shared was given.
+if test "${enable_shared+set}" = set; then :
+  enableval=$enable_shared; 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
+else
+  enable_shared=yes
+fi
+
+
+
+
+
+
+
+
+
+  # Check whether --enable-static was given.
+if test "${enable_static+set}" = set; then :
+  enableval=$enable_static; 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
+else
+  enable_static=yes
+fi
+
+
+
+
+
+
+
+
+
+
+# Check whether --with-pic was given.
+if test "${with_pic+set}" = set; then :
+  withval=$with_pic; pic_mode="$withval"
+else
+  pic_mode=default
+fi
+
+
+test -z "$pic_mode" && pic_mode=default
+
+
+
+
+
+
+
+  # Check whether --enable-fast-install was given.
+if test "${enable_fast_install+set}" = set; then :
+  enableval=$enable_fast_install; 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
+else
+  enable_fast_install=yes
+fi
+
+
+
+
+
+
+
+
+
+
+
+# This can be used to rebuild libtool when needed
+LIBTOOL_DEPS="$ltmain"
+
+# Always use our own libtool.
+LIBTOOL='$(SHELL) $(top_builddir)/libtool'
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+test -z "$LN_S" && LN_S="ln -s"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+if test -n "${ZSH_VERSION+set}" ; then
+   setopt NO_GLOB_SUBST
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for objdir" >&5
+$as_echo_n "checking for objdir... " >&6; }
+if test "${lt_cv_objdir+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  rm -f .libs 2>/dev/null
+mkdir .libs 2>/dev/null
+if test -d .libs; then
+  lt_cv_objdir=.libs
+else
+  # MS-DOS does not allow filenames that begin with a dot.
+  lt_cv_objdir=_libs
+fi
+rmdir .libs 2>/dev/null
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_objdir" >&5
+$as_echo "$lt_cv_objdir" >&6; }
+objdir=$lt_cv_objdir
+
+
+
+
+
+cat >>confdefs.h <<_ACEOF
+#define LT_OBJDIR "$lt_cv_objdir/"
+_ACEOF
+
+
+
+
+case $host_os in
+aix3*)
+  # AIX sometimes has problems with the GCC collect2 program.  For some
+  # reason, if we set the COLLECT_NAMES environment variable, the problems
+  # vanish in a puff of smoke.
+  if test "X${COLLECT_NAMES+set}" != Xset; then
+    COLLECT_NAMES=
+    export COLLECT_NAMES
+  fi
+  ;;
+esac
+
+# Global variables:
+ofile=libtool
+can_build_shared=yes
+
+# All known linkers require a `.a' archive for static linking (except MSVC,
+# which needs '.lib').
+libext=a
+
+with_gnu_ld="$lt_cv_prog_gnu_ld"
+
+old_CC="$CC"
+old_CFLAGS="$CFLAGS"
+
+# Set sane defaults for various variables
+test -z "$CC" && CC=cc
+test -z "$LTCC" && LTCC=$CC
+test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
+test -z "$LD" && LD=ld
+test -z "$ac_objext" && ac_objext=o
+
+for cc_temp in $compiler""; do
+  case $cc_temp in
+    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
+    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
+    \-*) ;;
+    *) break;;
+  esac
+done
+cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
+
+
+# Only perform the check for file, if the check method requires it
+test -z "$MAGIC_CMD" && MAGIC_CMD=file
+case $deplibs_check_method in
+file_magic*)
+  if test "$file_magic_cmd" = '$MAGIC_CMD'; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ac_tool_prefix}file" >&5
+$as_echo_n "checking for ${ac_tool_prefix}file... " >&6; }
+if test "${lt_cv_path_MAGIC_CMD+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  case $MAGIC_CMD in
+[\\/*] |  ?:[\\/]*)
+  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
+  ;;
+*)
+  lt_save_MAGIC_CMD="$MAGIC_CMD"
+  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+  ac_dummy="/usr/bin$PATH_SEPARATOR$PATH"
+  for ac_dir in $ac_dummy; do
+    IFS="$lt_save_ifs"
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/${ac_tool_prefix}file; then
+      lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file"
+      if test -n "$file_magic_test_file"; then
+	case $deplibs_check_method in
+	"file_magic "*)
+	  file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
+	  MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
+	    $EGREP "$file_magic_regex" > /dev/null; then
+	    :
+	  else
+	    cat <<_LT_EOF 1>&2
+
+*** Warning: the command libtool uses to detect shared libraries,
+*** $file_magic_cmd, produces output that libtool cannot recognize.
+*** The result is that libtool may fail to recognize shared libraries
+*** as such.  This will affect the creation of libtool libraries that
+*** depend on shared libraries, but programs linked with such libtool
+*** libraries will work regardless of this problem.  Nevertheless, you
+*** may want to report the problem to your system manager and/or to
+*** bug-libtool@gnu.org
+
+_LT_EOF
+	  fi ;;
+	esac
+      fi
+      break
+    fi
+  done
+  IFS="$lt_save_ifs"
+  MAGIC_CMD="$lt_save_MAGIC_CMD"
+  ;;
+esac
+fi
+
+MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+if test -n "$MAGIC_CMD"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5
+$as_echo "$MAGIC_CMD" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+
+
+
+if test -z "$lt_cv_path_MAGIC_CMD"; then
+  if test -n "$ac_tool_prefix"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for file" >&5
+$as_echo_n "checking for file... " >&6; }
+if test "${lt_cv_path_MAGIC_CMD+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  case $MAGIC_CMD in
+[\\/*] |  ?:[\\/]*)
+  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
+  ;;
+*)
+  lt_save_MAGIC_CMD="$MAGIC_CMD"
+  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+  ac_dummy="/usr/bin$PATH_SEPARATOR$PATH"
+  for ac_dir in $ac_dummy; do
+    IFS="$lt_save_ifs"
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/file; then
+      lt_cv_path_MAGIC_CMD="$ac_dir/file"
+      if test -n "$file_magic_test_file"; then
+	case $deplibs_check_method in
+	"file_magic "*)
+	  file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
+	  MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
+	    $EGREP "$file_magic_regex" > /dev/null; then
+	    :
+	  else
+	    cat <<_LT_EOF 1>&2
+
+*** Warning: the command libtool uses to detect shared libraries,
+*** $file_magic_cmd, produces output that libtool cannot recognize.
+*** The result is that libtool may fail to recognize shared libraries
+*** as such.  This will affect the creation of libtool libraries that
+*** depend on shared libraries, but programs linked with such libtool
+*** libraries will work regardless of this problem.  Nevertheless, you
+*** may want to report the problem to your system manager and/or to
+*** bug-libtool@gnu.org
+
+_LT_EOF
+	  fi ;;
+	esac
+      fi
+      break
+    fi
+  done
+  IFS="$lt_save_ifs"
+  MAGIC_CMD="$lt_save_MAGIC_CMD"
+  ;;
+esac
+fi
+
+MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+if test -n "$MAGIC_CMD"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5
+$as_echo "$MAGIC_CMD" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  else
+    MAGIC_CMD=:
+  fi
+fi
+
+  fi
+  ;;
+esac
+
+# Use C for the default configuration in the libtool script
+
+lt_save_CC="$CC"
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+# Source file extension for C test sources.
+ac_ext=c
+
+# Object file extension for compiled C test sources.
+objext=o
+objext=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="int some_variable = 0;"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code='int main(){return(0);}'
+
+
+
+
+
+
+
+# If no C compiler was specified, use CC.
+LTCC=${LTCC-"$CC"}
+
+# If no C compiler flags were specified, use CFLAGS.
+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
+
+# Allow CC to be a program name with arguments.
+compiler=$CC
+
+# Save the default compiler, since it gets overwritten when the other
+# tags are being tested, and _LT_TAGVAR(compiler, []) is a NOP.
+compiler_DEFAULT=$CC
+
+# save warnings/boilerplate of simple test code
+ac_outfile=conftest.$ac_objext
+echo "$lt_simple_compile_test_code" >conftest.$ac_ext
+eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_compiler_boilerplate=`cat conftest.err`
+$RM conftest*
+
+ac_outfile=conftest.$ac_objext
+echo "$lt_simple_link_test_code" >conftest.$ac_ext
+eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_linker_boilerplate=`cat conftest.err`
+$RM -r conftest*
+
+
+## CAVEAT EMPTOR:
+## There is no encapsulation within the following macros, do not change
+## the running order or otherwise move them around unless you know exactly
+## what you are doing...
+if test -n "$compiler"; then
+
+lt_prog_compiler_no_builtin_flag=
+
+if test "$GCC" = yes; then
+  case $cc_basename in
+  nvcc*)
+    lt_prog_compiler_no_builtin_flag=' -Xcompiler -fno-builtin' ;;
+  *)
+    lt_prog_compiler_no_builtin_flag=' -fno-builtin' ;;
+  esac
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -fno-rtti -fno-exceptions" >&5
+$as_echo_n "checking if $compiler supports -fno-rtti -fno-exceptions... " >&6; }
+if test "${lt_cv_prog_compiler_rtti_exceptions+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_prog_compiler_rtti_exceptions=no
+   ac_outfile=conftest.$ac_objext
+   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+   lt_compiler_flag="-fno-rtti -fno-exceptions"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   # The option is referenced via a variable to avoid confusing sed.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>conftest.err)
+   ac_status=$?
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s "$ac_outfile"; then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings other than the usual output.
+     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
+     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_rtti_exceptions=yes
+     fi
+   fi
+   $RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5
+$as_echo "$lt_cv_prog_compiler_rtti_exceptions" >&6; }
+
+if test x"$lt_cv_prog_compiler_rtti_exceptions" = xyes; then
+    lt_prog_compiler_no_builtin_flag="$lt_prog_compiler_no_builtin_flag -fno-rtti -fno-exceptions"
+else
+    :
+fi
+
+fi
+
+
+
+
+
+
+  lt_prog_compiler_wl=
+lt_prog_compiler_pic=
+lt_prog_compiler_static=
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5
+$as_echo_n "checking for $compiler option to produce PIC... " >&6; }
+
+  if test "$GCC" = yes; then
+    lt_prog_compiler_wl='-Wl,'
+    lt_prog_compiler_static='-static'
+
+    case $host_os in
+      aix*)
+      # All AIX code is PIC.
+      if test "$host_cpu" = ia64; then
+	# AIX 5 now supports IA64 processor
+	lt_prog_compiler_static='-Bstatic'
+      fi
+      lt_prog_compiler_pic='-fPIC'
+      ;;
+
+    amigaos*)
+      case $host_cpu in
+      powerpc)
+            # see comment about AmigaOS4 .so support
+            lt_prog_compiler_pic='-fPIC'
+        ;;
+      m68k)
+            # FIXME: we need at least 68020 code to build shared libraries, but
+            # adding the `-m68020' flag to GCC prevents building anything better,
+            # like `-m68040'.
+            lt_prog_compiler_pic='-m68020 -resident32 -malways-restore-a4'
+        ;;
+      esac
+      ;;
+
+    beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
+      # PIC is the default for these OSes.
+      ;;
+
+    mingw* | cygwin* | pw32* | os2* | cegcc*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      # Although the cygwin gcc ignores -fPIC, still need this for old-style
+      # (--disable-auto-import) libraries
+      lt_prog_compiler_pic='-DDLL_EXPORT'
+      ;;
+
+    darwin* | rhapsody*)
+      # PIC is the default on this platform
+      # Common symbols not allowed in MH_DYLIB files
+      lt_prog_compiler_pic='-fno-common'
+      ;;
+
+    haiku*)
+      # PIC is the default for Haiku.
+      # The "-static" flag exists, but is broken.
+      lt_prog_compiler_static=
+      ;;
+
+    hpux*)
+      # PIC is the default for 64-bit PA HP-UX, but not for 32-bit
+      # PA HP-UX.  On IA64 HP-UX, PIC is the default but the pic flag
+      # sets the default TLS model and affects inlining.
+      case $host_cpu in
+      hppa*64*)
+	# +Z the default
+	;;
+      *)
+	lt_prog_compiler_pic='-fPIC'
+	;;
+      esac
+      ;;
+
+    interix[3-9]*)
+      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
+      # Instead, we relocate shared libraries at runtime.
+      ;;
+
+    msdosdjgpp*)
+      # Just because we use GCC doesn't mean we suddenly get shared libraries
+      # on systems that don't support them.
+      lt_prog_compiler_can_build_shared=no
+      enable_shared=no
+      ;;
+
+    *nto* | *qnx*)
+      # QNX uses GNU C++, but need to define -shared option too, otherwise
+      # it will coredump.
+      lt_prog_compiler_pic='-fPIC -shared'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	lt_prog_compiler_pic=-Kconform_pic
+      fi
+      ;;
+
+    *)
+      lt_prog_compiler_pic='-fPIC'
+      ;;
+    esac
+
+    case $cc_basename in
+    nvcc*) # Cuda Compiler Driver 2.2
+      lt_prog_compiler_wl='-Xlinker '
+      lt_prog_compiler_pic='-Xcompiler -fPIC'
+      ;;
+    esac
+  else
+    # PORTME Check for flag to pass linker flags through the system compiler.
+    case $host_os in
+    aix*)
+      lt_prog_compiler_wl='-Wl,'
+      if test "$host_cpu" = ia64; then
+	# AIX 5 now supports IA64 processor
+	lt_prog_compiler_static='-Bstatic'
+      else
+	lt_prog_compiler_static='-bnso -bI:/lib/syscalls.exp'
+      fi
+      ;;
+
+    mingw* | cygwin* | pw32* | os2* | cegcc*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      lt_prog_compiler_pic='-DDLL_EXPORT'
+      ;;
+
+    hpux9* | hpux10* | hpux11*)
+      lt_prog_compiler_wl='-Wl,'
+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
+      # not for PA HP-UX.
+      case $host_cpu in
+      hppa*64*|ia64*)
+	# +Z the default
+	;;
+      *)
+	lt_prog_compiler_pic='+Z'
+	;;
+      esac
+      # Is there a better lt_prog_compiler_static that works with the bundled CC?
+      lt_prog_compiler_static='${wl}-a ${wl}archive'
+      ;;
+
+    irix5* | irix6* | nonstopux*)
+      lt_prog_compiler_wl='-Wl,'
+      # PIC (with -KPIC) is the default.
+      lt_prog_compiler_static='-non_shared'
+      ;;
+
+    linux* | k*bsd*-gnu | kopensolaris*-gnu)
+      case $cc_basename in
+      # old Intel for x86_64 which still supported -KPIC.
+      ecc*)
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='-KPIC'
+	lt_prog_compiler_static='-static'
+        ;;
+      # icc used to be incompatible with GCC.
+      # ICC 10 doesn't accept -KPIC any more.
+      icc* | ifort*)
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='-fPIC'
+	lt_prog_compiler_static='-static'
+        ;;
+      # Lahey Fortran 8.1.
+      lf95*)
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='--shared'
+	lt_prog_compiler_static='--static'
+	;;
+      pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*)
+        # Portland Group compilers (*not* the Pentium gcc compiler,
+	# which looks to be a dead project)
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='-fpic'
+	lt_prog_compiler_static='-Bstatic'
+        ;;
+      ccc*)
+        lt_prog_compiler_wl='-Wl,'
+        # All Alpha code is PIC.
+        lt_prog_compiler_static='-non_shared'
+        ;;
+      xl* | bgxl* | bgf* | mpixl*)
+	# IBM XL C 8.0/Fortran 10.1, 11.1 on PPC and BlueGene
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='-qpic'
+	lt_prog_compiler_static='-qstaticlink'
+	;;
+      *)
+	case `$CC -V 2>&1 | sed 5q` in
+	*Sun\ F* | *Sun*Fortran*)
+	  # Sun Fortran 8.3 passes all unrecognized flags to the linker
+	  lt_prog_compiler_pic='-KPIC'
+	  lt_prog_compiler_static='-Bstatic'
+	  lt_prog_compiler_wl=''
+	  ;;
+	*Sun\ C*)
+	  # Sun C 5.9
+	  lt_prog_compiler_pic='-KPIC'
+	  lt_prog_compiler_static='-Bstatic'
+	  lt_prog_compiler_wl='-Wl,'
+	  ;;
+	esac
+	;;
+      esac
+      ;;
+
+    newsos6)
+      lt_prog_compiler_pic='-KPIC'
+      lt_prog_compiler_static='-Bstatic'
+      ;;
+
+    *nto* | *qnx*)
+      # QNX uses GNU C++, but need to define -shared option too, otherwise
+      # it will coredump.
+      lt_prog_compiler_pic='-fPIC -shared'
+      ;;
+
+    osf3* | osf4* | osf5*)
+      lt_prog_compiler_wl='-Wl,'
+      # All OSF/1 code is PIC.
+      lt_prog_compiler_static='-non_shared'
+      ;;
+
+    rdos*)
+      lt_prog_compiler_static='-non_shared'
+      ;;
+
+    solaris*)
+      lt_prog_compiler_pic='-KPIC'
+      lt_prog_compiler_static='-Bstatic'
+      case $cc_basename in
+      f77* | f90* | f95*)
+	lt_prog_compiler_wl='-Qoption ld ';;
+      *)
+	lt_prog_compiler_wl='-Wl,';;
+      esac
+      ;;
+
+    sunos4*)
+      lt_prog_compiler_wl='-Qoption ld '
+      lt_prog_compiler_pic='-PIC'
+      lt_prog_compiler_static='-Bstatic'
+      ;;
+
+    sysv4 | sysv4.2uw2* | sysv4.3*)
+      lt_prog_compiler_wl='-Wl,'
+      lt_prog_compiler_pic='-KPIC'
+      lt_prog_compiler_static='-Bstatic'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec ;then
+	lt_prog_compiler_pic='-Kconform_pic'
+	lt_prog_compiler_static='-Bstatic'
+      fi
+      ;;
+
+    sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
+      lt_prog_compiler_wl='-Wl,'
+      lt_prog_compiler_pic='-KPIC'
+      lt_prog_compiler_static='-Bstatic'
+      ;;
+
+    unicos*)
+      lt_prog_compiler_wl='-Wl,'
+      lt_prog_compiler_can_build_shared=no
+      ;;
+
+    uts4*)
+      lt_prog_compiler_pic='-pic'
+      lt_prog_compiler_static='-Bstatic'
+      ;;
+
+    *)
+      lt_prog_compiler_can_build_shared=no
+      ;;
+    esac
+  fi
+
+case $host_os in
+  # For platforms which do not support PIC, -DPIC is meaningless:
+  *djgpp*)
+    lt_prog_compiler_pic=
+    ;;
+  *)
+    lt_prog_compiler_pic="$lt_prog_compiler_pic -DPIC"
+    ;;
+esac
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_prog_compiler_pic" >&5
+$as_echo "$lt_prog_compiler_pic" >&6; }
+
+
+
+
+
+
+#
+# Check to make sure the PIC flag actually works.
+#
+if test -n "$lt_prog_compiler_pic"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5
+$as_echo_n "checking if $compiler PIC flag $lt_prog_compiler_pic works... " >&6; }
+if test "${lt_cv_prog_compiler_pic_works+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_prog_compiler_pic_works=no
+   ac_outfile=conftest.$ac_objext
+   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+   lt_compiler_flag="$lt_prog_compiler_pic -DPIC"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   # The option is referenced via a variable to avoid confusing sed.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>conftest.err)
+   ac_status=$?
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s "$ac_outfile"; then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings other than the usual output.
+     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
+     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_pic_works=yes
+     fi
+   fi
+   $RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5
+$as_echo "$lt_cv_prog_compiler_pic_works" >&6; }
+
+if test x"$lt_cv_prog_compiler_pic_works" = xyes; then
+    case $lt_prog_compiler_pic in
+     "" | " "*) ;;
+     *) lt_prog_compiler_pic=" $lt_prog_compiler_pic" ;;
+     esac
+else
+    lt_prog_compiler_pic=
+     lt_prog_compiler_can_build_shared=no
+fi
+
+fi
+
+
+
+
+
+
+#
+# Check to make sure the static flag actually works.
+#
+wl=$lt_prog_compiler_wl eval lt_tmp_static_flag=\"$lt_prog_compiler_static\"
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5
+$as_echo_n "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; }
+if test "${lt_cv_prog_compiler_static_works+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_prog_compiler_static_works=no
+   save_LDFLAGS="$LDFLAGS"
+   LDFLAGS="$LDFLAGS $lt_tmp_static_flag"
+   echo "$lt_simple_link_test_code" > conftest.$ac_ext
+   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
+     # The linker can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     if test -s conftest.err; then
+       # Append any errors to the config.log.
+       cat conftest.err 1>&5
+       $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
+       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+       if diff conftest.exp conftest.er2 >/dev/null; then
+         lt_cv_prog_compiler_static_works=yes
+       fi
+     else
+       lt_cv_prog_compiler_static_works=yes
+     fi
+   fi
+   $RM -r conftest*
+   LDFLAGS="$save_LDFLAGS"
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5
+$as_echo "$lt_cv_prog_compiler_static_works" >&6; }
+
+if test x"$lt_cv_prog_compiler_static_works" = xyes; then
+    :
+else
+    lt_prog_compiler_static=
+fi
+
+
+
+
+
+
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
+$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
+if test "${lt_cv_prog_compiler_c_o+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_prog_compiler_c_o=no
+   $RM -r conftest 2>/dev/null
+   mkdir conftest
+   cd conftest
+   mkdir out
+   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+   lt_compiler_flag="-o out/conftest2.$ac_objext"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>out/conftest.err)
+   ac_status=$?
+   cat out/conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s out/conftest2.$ac_objext
+   then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
+     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
+     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_c_o=yes
+     fi
+   fi
+   chmod u+w . 2>&5
+   $RM conftest*
+   # SGI C++ compiler will create directory out/ii_files/ for
+   # template instantiation
+   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
+   $RM out/* && rmdir out
+   cd ..
+   $RM -r conftest
+   $RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5
+$as_echo "$lt_cv_prog_compiler_c_o" >&6; }
+
+
+
+
+
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
+$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
+if test "${lt_cv_prog_compiler_c_o+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_prog_compiler_c_o=no
+   $RM -r conftest 2>/dev/null
+   mkdir conftest
+   cd conftest
+   mkdir out
+   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+   lt_compiler_flag="-o out/conftest2.$ac_objext"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>out/conftest.err)
+   ac_status=$?
+   cat out/conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s out/conftest2.$ac_objext
+   then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
+     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
+     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_c_o=yes
+     fi
+   fi
+   chmod u+w . 2>&5
+   $RM conftest*
+   # SGI C++ compiler will create directory out/ii_files/ for
+   # template instantiation
+   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
+   $RM out/* && rmdir out
+   cd ..
+   $RM -r conftest
+   $RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5
+$as_echo "$lt_cv_prog_compiler_c_o" >&6; }
+
+
+
+
+hard_links="nottested"
+if test "$lt_cv_prog_compiler_c_o" = no && test "$need_locks" != no; then
+  # do not overwrite the value of need_locks provided by the user
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5
+$as_echo_n "checking if we can lock with hard links... " >&6; }
+  hard_links=yes
+  $RM conftest*
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  touch conftest.a
+  ln conftest.a conftest.b 2>&5 || hard_links=no
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5
+$as_echo "$hard_links" >&6; }
+  if test "$hard_links" = no; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5
+$as_echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;}
+    need_locks=warn
+  fi
+else
+  need_locks=no
+fi
+
+
+
+
+
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5
+$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; }
+
+  runpath_var=
+  allow_undefined_flag=
+  always_export_symbols=no
+  archive_cmds=
+  archive_expsym_cmds=
+  compiler_needs_object=no
+  enable_shared_with_static_runtimes=no
+  export_dynamic_flag_spec=
+  export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+  hardcode_automatic=no
+  hardcode_direct=no
+  hardcode_direct_absolute=no
+  hardcode_libdir_flag_spec=
+  hardcode_libdir_flag_spec_ld=
+  hardcode_libdir_separator=
+  hardcode_minus_L=no
+  hardcode_shlibpath_var=unsupported
+  inherit_rpath=no
+  link_all_deplibs=unknown
+  module_cmds=
+  module_expsym_cmds=
+  old_archive_from_new_cmds=
+  old_archive_from_expsyms_cmds=
+  thread_safe_flag_spec=
+  whole_archive_flag_spec=
+  # include_expsyms should be a list of space-separated symbols to be *always*
+  # included in the symbol list
+  include_expsyms=
+  # exclude_expsyms can be an extended regexp of symbols to exclude
+  # it will be wrapped by ` (' and `)$', so one must not match beginning or
+  # end of line.  Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc',
+  # as well as any symbol that contains `d'.
+  exclude_expsyms='_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'
+  # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out
+  # platforms (ab)use it in PIC code, but their linkers get confused if
+  # the symbol is explicitly referenced.  Since portable code cannot
+  # rely on this symbol name, it's probably fine to never include it in
+  # preloaded symbol tables.
+  # Exclude shared library initialization/finalization symbols.
+  extract_expsyms_cmds=
+
+  case $host_os in
+  cygwin* | mingw* | pw32* | cegcc*)
+    # FIXME: the MSVC++ port hasn't been tested in a loooong time
+    # When not using gcc, we currently assume that we are using
+    # Microsoft Visual C++.
+    if test "$GCC" != yes; then
+      with_gnu_ld=no
+    fi
+    ;;
+  interix*)
+    # we just hope/assume this is gcc and not c89 (= MSVC++)
+    with_gnu_ld=yes
+    ;;
+  openbsd*)
+    with_gnu_ld=no
+    ;;
+  esac
+
+  ld_shlibs=yes
+
+  # On some targets, GNU ld is compatible enough with the native linker
+  # that we're better off using the native interface for both.
+  lt_use_gnu_ld_interface=no
+  if test "$with_gnu_ld" = yes; then
+    case $host_os in
+      aix*)
+	# The AIX port of GNU ld has always aspired to compatibility
+	# with the native linker.  However, as the warning in the GNU ld
+	# block says, versions before 2.19.5* couldn't really create working
+	# shared libraries, regardless of the interface used.
+	case `$LD -v 2>&1` in
+	  *\ \(GNU\ Binutils\)\ 2.19.5*) ;;
+	  *\ \(GNU\ Binutils\)\ 2.[2-9]*) ;;
+	  *\ \(GNU\ Binutils\)\ [3-9]*) ;;
+	  *)
+	    lt_use_gnu_ld_interface=yes
+	    ;;
+	esac
+	;;
+      *)
+	lt_use_gnu_ld_interface=yes
+	;;
+    esac
+  fi
+
+  if test "$lt_use_gnu_ld_interface" = yes; then
+    # If archive_cmds runs LD, not CC, wlarc should be empty
+    wlarc='${wl}'
+
+    # Set some defaults for GNU ld with shared library support. These
+    # are reset later if shared libraries are not supported. Putting them
+    # here allows them to be overridden if necessary.
+    runpath_var=LD_RUN_PATH
+    hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+    export_dynamic_flag_spec='${wl}--export-dynamic'
+    # ancient GNU ld didn't support --whole-archive et. al.
+    if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then
+      whole_archive_flag_spec="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+    else
+      whole_archive_flag_spec=
+    fi
+    supports_anon_versioning=no
+    case `$LD -v 2>&1` in
+      *GNU\ gold*) supports_anon_versioning=yes ;;
+      *\ [01].* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11
+      *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
+      *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
+      *\ 2.11.*) ;; # other 2.11 versions
+      *) supports_anon_versioning=yes ;;
+    esac
+
+    # See if GNU ld supports shared libraries.
+    case $host_os in
+    aix[3-9]*)
+      # On AIX/PPC, the GNU linker is very broken
+      if test "$host_cpu" != ia64; then
+	ld_shlibs=no
+	cat <<_LT_EOF 1>&2
+
+*** Warning: the GNU linker, at least up to release 2.19, is reported
+*** to be unable to reliably create shared libraries on AIX.
+*** Therefore, libtool is disabling shared libraries support.  If you
+*** really care for shared libraries, you may want to install binutils
+*** 2.20 or above, or modify your PATH so that a non-GNU linker is found.
+*** You will then need to restart the configuration process.
+
+_LT_EOF
+      fi
+      ;;
+
+    amigaos*)
+      case $host_cpu in
+      powerpc)
+            # see comment about AmigaOS4 .so support
+            archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+            archive_expsym_cmds=''
+        ;;
+      m68k)
+            archive_cmds='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
+            hardcode_libdir_flag_spec='-L$libdir'
+            hardcode_minus_L=yes
+        ;;
+      esac
+      ;;
+
+    beos*)
+      if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+	allow_undefined_flag=unsupported
+	# Joseph Beckenbach <jrb3@best.com> says some releases of gcc
+	# support --undefined.  This deserves some investigation.  FIXME
+	archive_cmds='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+      else
+	ld_shlibs=no
+      fi
+      ;;
+
+    cygwin* | mingw* | pw32* | cegcc*)
+      # _LT_TAGVAR(hardcode_libdir_flag_spec, ) is actually meaningless,
+      # as there is no search path for DLLs.
+      hardcode_libdir_flag_spec='-L$libdir'
+      export_dynamic_flag_spec='${wl}--export-all-symbols'
+      allow_undefined_flag=unsupported
+      always_export_symbols=no
+      enable_shared_with_static_runtimes=yes
+      export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1 DATA/'\'' | $SED -e '\''/^[AITW][ ]/s/.*[ ]//'\'' | sort | uniq > $export_symbols'
+
+      if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
+        archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+	# If the export-symbols file already is a .def file (1st line
+	# is EXPORTS), use it as is; otherwise, prepend...
+	archive_expsym_cmds='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
+	  cp $export_symbols $output_objdir/$soname.def;
+	else
+	  echo EXPORTS > $output_objdir/$soname.def;
+	  cat $export_symbols >> $output_objdir/$soname.def;
+	fi~
+	$CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+      else
+	ld_shlibs=no
+      fi
+      ;;
+
+    haiku*)
+      archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+      link_all_deplibs=yes
+      ;;
+
+    interix[3-9]*)
+      hardcode_direct=no
+      hardcode_shlibpath_var=no
+      hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
+      export_dynamic_flag_spec='${wl}-E'
+      # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
+      # Instead, shared libraries are loaded at an image base (0x10000000 by
+      # default) and relocated if they conflict, which is a slow very memory
+      # consuming and fragmenting process.  To avoid this, we pick a random,
+      # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
+      # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
+      archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+      archive_expsym_cmds='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+      ;;
+
+    gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu)
+      tmp_diet=no
+      if test "$host_os" = linux-dietlibc; then
+	case $cc_basename in
+	  diet\ *) tmp_diet=yes;;	# linux-dietlibc with static linking (!diet-dyn)
+	esac
+      fi
+      if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \
+	 && test "$tmp_diet" = no
+      then
+	tmp_addflag=
+	tmp_sharedflag='-shared'
+	case $cc_basename,$host_cpu in
+        pgcc*)				# Portland Group C compiler
+	  whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+	  tmp_addflag=' $pic_flag'
+	  ;;
+	pgf77* | pgf90* | pgf95* | pgfortran*)
+					# Portland Group f77 and f90 compilers
+	  whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+	  tmp_addflag=' $pic_flag -Mnomain' ;;
+	ecc*,ia64* | icc*,ia64*)	# Intel C compiler on ia64
+	  tmp_addflag=' -i_dynamic' ;;
+	efc*,ia64* | ifort*,ia64*)	# Intel Fortran compiler on ia64
+	  tmp_addflag=' -i_dynamic -nofor_main' ;;
+	ifc* | ifort*)			# Intel Fortran compiler
+	  tmp_addflag=' -nofor_main' ;;
+	lf95*)				# Lahey Fortran 8.1
+	  whole_archive_flag_spec=
+	  tmp_sharedflag='--shared' ;;
+	xl[cC]* | bgxl[cC]* | mpixl[cC]*) # IBM XL C 8.0 on PPC (deal with xlf below)
+	  tmp_sharedflag='-qmkshrobj'
+	  tmp_addflag= ;;
+	nvcc*)	# Cuda Compiler Driver 2.2
+	  whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+	  compiler_needs_object=yes
+	  ;;
+	esac
+	case `$CC -V 2>&1 | sed 5q` in
+	*Sun\ C*)			# Sun C 5.9
+	  whole_archive_flag_spec='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+	  compiler_needs_object=yes
+	  tmp_sharedflag='-G' ;;
+	*Sun\ F*)			# Sun Fortran 8.3
+	  tmp_sharedflag='-G' ;;
+	esac
+	archive_cmds='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+
+        if test "x$supports_anon_versioning" = xyes; then
+          archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~
+	    cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+	    echo "local: *; };" >> $output_objdir/$libname.ver~
+	    $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
+        fi
+
+	case $cc_basename in
+	xlf* | bgf* | bgxlf* | mpixlf*)
+	  # IBM XL Fortran 10.1 on PPC cannot create shared libs itself
+	  whole_archive_flag_spec='--whole-archive$convenience --no-whole-archive'
+	  hardcode_libdir_flag_spec=
+	  hardcode_libdir_flag_spec_ld='-rpath $libdir'
+	  archive_cmds='$LD -shared $libobjs $deplibs $compiler_flags -soname $soname -o $lib'
+	  if test "x$supports_anon_versioning" = xyes; then
+	    archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~
+	      cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+	      echo "local: *; };" >> $output_objdir/$libname.ver~
+	      $LD -shared $libobjs $deplibs $compiler_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib'
+	  fi
+	  ;;
+	esac
+      else
+        ld_shlibs=no
+      fi
+      ;;
+
+    netbsd*)
+      if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+	archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
+	wlarc=
+      else
+	archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+      fi
+      ;;
+
+    solaris*)
+      if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then
+	ld_shlibs=no
+	cat <<_LT_EOF 1>&2
+
+*** Warning: The releases 2.8.* of the GNU linker cannot reliably
+*** create shared libraries on Solaris systems.  Therefore, libtool
+*** is disabling shared libraries support.  We urge you to upgrade GNU
+*** binutils to release 2.9.1 or newer.  Another option is to modify
+*** your PATH or compiler configuration so that the native linker is
+*** used, and then restart.
+
+_LT_EOF
+      elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+	archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+      else
+	ld_shlibs=no
+      fi
+      ;;
+
+    sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)
+      case `$LD -v 2>&1` in
+        *\ [01].* | *\ 2.[0-9].* | *\ 2.1[0-5].*)
+	ld_shlibs=no
+	cat <<_LT_EOF 1>&2
+
+*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not
+*** reliably create shared libraries on SCO systems.  Therefore, libtool
+*** is disabling shared libraries support.  We urge you to upgrade GNU
+*** binutils to release 2.16.91.0.3 or newer.  Another option is to modify
+*** your PATH or compiler configuration so that the native linker is
+*** used, and then restart.
+
+_LT_EOF
+	;;
+	*)
+	  # For security reasons, it is highly recommended that you always
+	  # use absolute paths for naming shared libraries, and exclude the
+	  # DT_RUNPATH tag from executables and libraries.  But doing so
+	  # requires that you compile everything twice, which is a pain.
+	  if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+	    hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+	    archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	    archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+	  else
+	    ld_shlibs=no
+	  fi
+	;;
+      esac
+      ;;
+
+    sunos4*)
+      archive_cmds='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+      wlarc=
+      hardcode_direct=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    *)
+      if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+	archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+      else
+	ld_shlibs=no
+      fi
+      ;;
+    esac
+
+    if test "$ld_shlibs" = no; then
+      runpath_var=
+      hardcode_libdir_flag_spec=
+      export_dynamic_flag_spec=
+      whole_archive_flag_spec=
+    fi
+  else
+    # PORTME fill in a description of your system's linker (not GNU ld)
+    case $host_os in
+    aix3*)
+      allow_undefined_flag=unsupported
+      always_export_symbols=yes
+      archive_expsym_cmds='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'
+      # Note: this linker hardcodes the directories in LIBPATH if there
+      # are no directories specified by -L.
+      hardcode_minus_L=yes
+      if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then
+	# Neither direct hardcoding nor static linking is supported with a
+	# broken collect2.
+	hardcode_direct=unsupported
+      fi
+      ;;
+
+    aix[4-9]*)
+      if test "$host_cpu" = ia64; then
+	# On IA64, the linker does run time linking by default, so we don't
+	# have to do anything special.
+	aix_use_runtimelinking=no
+	exp_sym_flag='-Bexport'
+	no_entry_flag=""
+      else
+	# If we're using GNU nm, then we don't want the "-C" option.
+	# -C means demangle to AIX nm, but means don't demangle with GNU nm
+	# Also, AIX nm treats weak defined symbols like other global
+	# defined symbols, whereas GNU nm marks them as "W".
+	if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
+	  export_symbols_cmds='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+	else
+	  export_symbols_cmds='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+	fi
+	aix_use_runtimelinking=no
+
+	# Test if we are trying to use run time linking or normal
+	# AIX style linking. If -brtl is somewhere in LDFLAGS, we
+	# need to do runtime linking.
+	case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*)
+	  for ld_flag in $LDFLAGS; do
+	  if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then
+	    aix_use_runtimelinking=yes
+	    break
+	  fi
+	  done
+	  ;;
+	esac
+
+	exp_sym_flag='-bexport'
+	no_entry_flag='-bnoentry'
+      fi
+
+      # When large executables or shared objects are built, AIX ld can
+      # have problems creating the table of contents.  If linking a library
+      # or program results in "error TOC overflow" add -mminimal-toc to
+      # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
+      # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
+
+      archive_cmds=''
+      hardcode_direct=yes
+      hardcode_direct_absolute=yes
+      hardcode_libdir_separator=':'
+      link_all_deplibs=yes
+      file_list_spec='${wl}-f,'
+
+      if test "$GCC" = yes; then
+	case $host_os in aix4.[012]|aix4.[012].*)
+	# We only want to do this on AIX 4.2 and lower, the check
+	# below for broken collect2 doesn't work under 4.3+
+	  collect2name=`${CC} -print-prog-name=collect2`
+	  if test -f "$collect2name" &&
+	   strings "$collect2name" | $GREP resolve_lib_name >/dev/null
+	  then
+	  # We have reworked collect2
+	  :
+	  else
+	  # We have old collect2
+	  hardcode_direct=unsupported
+	  # It fails to find uninstalled libraries when the uninstalled
+	  # path is not listed in the libpath.  Setting hardcode_minus_L
+	  # to unsupported forces relinking
+	  hardcode_minus_L=yes
+	  hardcode_libdir_flag_spec='-L$libdir'
+	  hardcode_libdir_separator=
+	  fi
+	  ;;
+	esac
+	shared_flag='-shared'
+	if test "$aix_use_runtimelinking" = yes; then
+	  shared_flag="$shared_flag "'${wl}-G'
+	fi
+      else
+	# not using gcc
+	if test "$host_cpu" = ia64; then
+	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
+	# chokes on -Wl,-G. The following line is correct:
+	  shared_flag='-G'
+	else
+	  if test "$aix_use_runtimelinking" = yes; then
+	    shared_flag='${wl}-G'
+	  else
+	    shared_flag='${wl}-bM:SRE'
+	  fi
+	fi
+      fi
+
+      export_dynamic_flag_spec='${wl}-bexpall'
+      # It seems that -bexpall does not export symbols beginning with
+      # underscore (_), so it is better to generate a list of symbols to export.
+      always_export_symbols=yes
+      if test "$aix_use_runtimelinking" = yes; then
+	# Warning - without using the other runtime loading flags (-brtl),
+	# -berok will link without error, but may produce a broken library.
+	allow_undefined_flag='-berok'
+        # Determine the default libpath from the value encoded in an
+        # empty executable.
+        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+
+lt_aix_libpath_sed='
+    /Import File Strings/,/^$/ {
+	/^0/ {
+	    s/^0  *\(.*\)$/\1/
+	    p
+	}
+    }'
+aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+# Check for a 64-bit object if we didn't find anything.
+if test -z "$aix_libpath"; then
+  aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+fi
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
+
+        hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"
+        archive_expsym_cmds='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
+      else
+	if test "$host_cpu" = ia64; then
+	  hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib'
+	  allow_undefined_flag="-z nodefs"
+	  archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
+	else
+	 # Determine the default libpath from the value encoded in an
+	 # empty executable.
+	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+
+lt_aix_libpath_sed='
+    /Import File Strings/,/^$/ {
+	/^0/ {
+	    s/^0  *\(.*\)$/\1/
+	    p
+	}
+    }'
+aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+# Check for a 64-bit object if we didn't find anything.
+if test -z "$aix_libpath"; then
+  aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+fi
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
+
+	 hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"
+	  # Warning - without using the other run time loading flags,
+	  # -berok will link without error, but may produce a broken library.
+	  no_undefined_flag=' ${wl}-bernotok'
+	  allow_undefined_flag=' ${wl}-berok'
+	  if test "$with_gnu_ld" = yes; then
+	    # We only use this code for GNU lds that support --whole-archive.
+	    whole_archive_flag_spec='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
+	  else
+	    # Exported symbols can be pulled into shared objects from archives
+	    whole_archive_flag_spec='$convenience'
+	  fi
+	  archive_cmds_need_lc=yes
+	  # This is similar to how AIX traditionally builds its shared libraries.
+	  archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
+	fi
+      fi
+      ;;
+
+    amigaos*)
+      case $host_cpu in
+      powerpc)
+            # see comment about AmigaOS4 .so support
+            archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+            archive_expsym_cmds=''
+        ;;
+      m68k)
+            archive_cmds='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
+            hardcode_libdir_flag_spec='-L$libdir'
+            hardcode_minus_L=yes
+        ;;
+      esac
+      ;;
+
+    bsdi[45]*)
+      export_dynamic_flag_spec=-rdynamic
+      ;;
+
+    cygwin* | mingw* | pw32* | cegcc*)
+      # When not using gcc, we currently assume that we are using
+      # Microsoft Visual C++.
+      # hardcode_libdir_flag_spec is actually meaningless, as there is
+      # no search path for DLLs.
+      hardcode_libdir_flag_spec=' '
+      allow_undefined_flag=unsupported
+      # Tell ltmain to make .lib files, not .a files.
+      libext=lib
+      # Tell ltmain to make .dll files, not .so files.
+      shrext_cmds=".dll"
+      # FIXME: Setting linknames here is a bad hack.
+      archive_cmds='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames='
+      # The linker will automatically build a .lib file if we build a DLL.
+      old_archive_from_new_cmds='true'
+      # FIXME: Should let the user specify the lib program.
+      old_archive_cmds='lib -OUT:$oldlib$oldobjs$old_deplibs'
+      fix_srcfile_path='`cygpath -w "$srcfile"`'
+      enable_shared_with_static_runtimes=yes
+      ;;
+
+    darwin* | rhapsody*)
+
+
+  archive_cmds_need_lc=no
+  hardcode_direct=no
+  hardcode_automatic=yes
+  hardcode_shlibpath_var=unsupported
+  if test "$lt_cv_ld_force_load" = "yes"; then
+    whole_archive_flag_spec='`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`'
+  else
+    whole_archive_flag_spec=''
+  fi
+  link_all_deplibs=yes
+  allow_undefined_flag="$_lt_dar_allow_undefined"
+  case $cc_basename in
+     ifort*) _lt_dar_can_shared=yes ;;
+     *) _lt_dar_can_shared=$GCC ;;
+  esac
+  if test "$_lt_dar_can_shared" = "yes"; then
+    output_verbose_link_cmd=func_echo_all
+    archive_cmds="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}"
+    module_cmds="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}"
+    archive_expsym_cmds="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}"
+    module_expsym_cmds="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}"
+
+  else
+  ld_shlibs=no
+  fi
+
+      ;;
+
+    dgux*)
+      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_shlibpath_var=no
+      ;;
+
+    # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor
+    # support.  Future versions do this automatically, but an explicit c++rt0.o
+    # does not break anything, and helps significantly (at the cost of a little
+    # extra space).
+    freebsd2.2*)
+      archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'
+      hardcode_libdir_flag_spec='-R$libdir'
+      hardcode_direct=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    # Unfortunately, older versions of FreeBSD 2 do not have this feature.
+    freebsd2.*)
+      archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_direct=yes
+      hardcode_minus_L=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
+    freebsd* | dragonfly*)
+      archive_cmds='$CC -shared -o $lib $libobjs $deplibs $compiler_flags'
+      hardcode_libdir_flag_spec='-R$libdir'
+      hardcode_direct=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    hpux9*)
+      if test "$GCC" = yes; then
+	archive_cmds='$RM $output_objdir/$soname~$CC -shared -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+      else
+	archive_cmds='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+      fi
+      hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
+      hardcode_libdir_separator=:
+      hardcode_direct=yes
+
+      # hardcode_minus_L: Not really in the search PATH,
+      # but as the default location of the library.
+      hardcode_minus_L=yes
+      export_dynamic_flag_spec='${wl}-E'
+      ;;
+
+    hpux10*)
+      if test "$GCC" = yes && test "$with_gnu_ld" = no; then
+	archive_cmds='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
+      fi
+      if test "$with_gnu_ld" = no; then
+	hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
+	hardcode_libdir_flag_spec_ld='+b $libdir'
+	hardcode_libdir_separator=:
+	hardcode_direct=yes
+	hardcode_direct_absolute=yes
+	export_dynamic_flag_spec='${wl}-E'
+	# hardcode_minus_L: Not really in the search PATH,
+	# but as the default location of the library.
+	hardcode_minus_L=yes
+      fi
+      ;;
+
+    hpux11*)
+      if test "$GCC" = yes && test "$with_gnu_ld" = no; then
+	case $host_cpu in
+	hppa*64*)
+	  archive_cmds='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	ia64*)
+	  archive_cmds='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	*)
+	  archive_cmds='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	esac
+      else
+	case $host_cpu in
+	hppa*64*)
+	  archive_cmds='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	ia64*)
+	  archive_cmds='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	*)
+
+	  # Older versions of the 11.00 compiler do not understand -b yet
+	  # (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does)
+	  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC understands -b" >&5
+$as_echo_n "checking if $CC understands -b... " >&6; }
+if test "${lt_cv_prog_compiler__b+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_prog_compiler__b=no
+   save_LDFLAGS="$LDFLAGS"
+   LDFLAGS="$LDFLAGS -b"
+   echo "$lt_simple_link_test_code" > conftest.$ac_ext
+   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
+     # The linker can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     if test -s conftest.err; then
+       # Append any errors to the config.log.
+       cat conftest.err 1>&5
+       $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
+       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+       if diff conftest.exp conftest.er2 >/dev/null; then
+         lt_cv_prog_compiler__b=yes
+       fi
+     else
+       lt_cv_prog_compiler__b=yes
+     fi
+   fi
+   $RM -r conftest*
+   LDFLAGS="$save_LDFLAGS"
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler__b" >&5
+$as_echo "$lt_cv_prog_compiler__b" >&6; }
+
+if test x"$lt_cv_prog_compiler__b" = xyes; then
+    archive_cmds='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+else
+    archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
+fi
+
+	  ;;
+	esac
+      fi
+      if test "$with_gnu_ld" = no; then
+	hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
+	hardcode_libdir_separator=:
+
+	case $host_cpu in
+	hppa*64*|ia64*)
+	  hardcode_direct=no
+	  hardcode_shlibpath_var=no
+	  ;;
+	*)
+	  hardcode_direct=yes
+	  hardcode_direct_absolute=yes
+	  export_dynamic_flag_spec='${wl}-E'
+
+	  # hardcode_minus_L: Not really in the search PATH,
+	  # but as the default location of the library.
+	  hardcode_minus_L=yes
+	  ;;
+	esac
+      fi
+      ;;
+
+    irix5* | irix6* | nonstopux*)
+      if test "$GCC" = yes; then
+	archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+	# Try to use the -exported_symbol ld option, if it does not
+	# work, assume that -exports_file does not work either and
+	# implicitly export all symbols.
+        save_LDFLAGS="$LDFLAGS"
+        LDFLAGS="$LDFLAGS -shared ${wl}-exported_symbol ${wl}foo ${wl}-update_registry ${wl}/dev/null"
+        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+int foo(void) {}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib'
+
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+        LDFLAGS="$save_LDFLAGS"
+      else
+	archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
+	archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -exports_file $export_symbols -o $lib'
+      fi
+      archive_cmds_need_lc='no'
+      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+      hardcode_libdir_separator=:
+      inherit_rpath=yes
+      link_all_deplibs=yes
+      ;;
+
+    netbsd*)
+      if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+	archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out
+      else
+	archive_cmds='$LD -shared -o $lib $libobjs $deplibs $linker_flags'      # ELF
+      fi
+      hardcode_libdir_flag_spec='-R$libdir'
+      hardcode_direct=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    newsos6)
+      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_direct=yes
+      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+      hardcode_libdir_separator=:
+      hardcode_shlibpath_var=no
+      ;;
+
+    *nto* | *qnx*)
+      ;;
+
+    openbsd*)
+      if test -f /usr/libexec/ld.so; then
+	hardcode_direct=yes
+	hardcode_shlibpath_var=no
+	hardcode_direct_absolute=yes
+	if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+	  archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	  archive_expsym_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols'
+	  hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
+	  export_dynamic_flag_spec='${wl}-E'
+	else
+	  case $host_os in
+	   openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*)
+	     archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+	     hardcode_libdir_flag_spec='-R$libdir'
+	     ;;
+	   *)
+	     archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	     hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
+	     ;;
+	  esac
+	fi
+      else
+	ld_shlibs=no
+      fi
+      ;;
+
+    os2*)
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_minus_L=yes
+      allow_undefined_flag=unsupported
+      archive_cmds='$ECHO "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~echo DATA >> $output_objdir/$libname.def~echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'
+      old_archive_from_new_cmds='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'
+      ;;
+
+    osf3*)
+      if test "$GCC" = yes; then
+	allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*'
+	archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+      else
+	allow_undefined_flag=' -expect_unresolved \*'
+	archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
+      fi
+      archive_cmds_need_lc='no'
+      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+      hardcode_libdir_separator=:
+      ;;
+
+    osf4* | osf5*)	# as osf3* with the addition of -msym flag
+      if test "$GCC" = yes; then
+	allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*'
+	archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+	hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+      else
+	allow_undefined_flag=' -expect_unresolved \*'
+	archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
+	archive_expsym_cmds='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~
+	$CC -shared${allow_undefined_flag} ${wl}-input ${wl}$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~$RM $lib.exp'
+
+	# Both c and cxx compiler support -rpath directly
+	hardcode_libdir_flag_spec='-rpath $libdir'
+      fi
+      archive_cmds_need_lc='no'
+      hardcode_libdir_separator=:
+      ;;
+
+    solaris*)
+      no_undefined_flag=' -z defs'
+      if test "$GCC" = yes; then
+	wlarc='${wl}'
+	archive_cmds='$CC -shared ${wl}-z ${wl}text ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+	  $CC -shared ${wl}-z ${wl}text ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
+      else
+	case `$CC -V 2>&1` in
+	*"Compilers 5.0"*)
+	  wlarc=''
+	  archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+	  $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp'
+	  ;;
+	*)
+	  wlarc='${wl}'
+	  archive_cmds='$CC -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $compiler_flags'
+	  archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+	  $CC -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
+	  ;;
+	esac
+      fi
+      hardcode_libdir_flag_spec='-R$libdir'
+      hardcode_shlibpath_var=no
+      case $host_os in
+      solaris2.[0-5] | solaris2.[0-5].*) ;;
+      *)
+	# The compiler driver will combine and reorder linker options,
+	# but understands `-z linker_flag'.  GCC discards it without `$wl',
+	# but is careful enough not to reorder.
+	# Supported since Solaris 2.6 (maybe 2.5.1?)
+	if test "$GCC" = yes; then
+	  whole_archive_flag_spec='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract'
+	else
+	  whole_archive_flag_spec='-z allextract$convenience -z defaultextract'
+	fi
+	;;
+      esac
+      link_all_deplibs=yes
+      ;;
+
+    sunos4*)
+      if test "x$host_vendor" = xsequent; then
+	# Use $CC to link under sequent, because it throws in some extra .o
+	# files that make .init and .fini sections work.
+	archive_cmds='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'
+      fi
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_direct=yes
+      hardcode_minus_L=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    sysv4)
+      case $host_vendor in
+	sni)
+	  archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  hardcode_direct=yes # is this really true???
+	;;
+	siemens)
+	  ## LD is ld it makes a PLAMLIB
+	  ## CC just makes a GrossModule.
+	  archive_cmds='$LD -G -o $lib $libobjs $deplibs $linker_flags'
+	  reload_cmds='$CC -r -o $output$reload_objs'
+	  hardcode_direct=no
+        ;;
+	motorola)
+	  archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  hardcode_direct=no #Motorola manual says yes, but my tests say they lie
+	;;
+      esac
+      runpath_var='LD_RUN_PATH'
+      hardcode_shlibpath_var=no
+      ;;
+
+    sysv4.3*)
+      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_shlibpath_var=no
+      export_dynamic_flag_spec='-Bexport'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	hardcode_shlibpath_var=no
+	runpath_var=LD_RUN_PATH
+	hardcode_runpath_var=yes
+	ld_shlibs=yes
+      fi
+      ;;
+
+    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*)
+      no_undefined_flag='${wl}-z,text'
+      archive_cmds_need_lc=no
+      hardcode_shlibpath_var=no
+      runpath_var='LD_RUN_PATH'
+
+      if test "$GCC" = yes; then
+	archive_cmds='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      fi
+      ;;
+
+    sysv5* | sco3.2v5* | sco5v6*)
+      # Note: We can NOT use -z defs as we might desire, because we do not
+      # link with -lc, and that would cause any symbols used from libc to
+      # always be unresolved, which means just about no library would
+      # ever link correctly.  If we're not using GNU ld we use -z text
+      # though, which does catch some bad symbols but isn't as heavy-handed
+      # as -z defs.
+      no_undefined_flag='${wl}-z,text'
+      allow_undefined_flag='${wl}-z,nodefs'
+      archive_cmds_need_lc=no
+      hardcode_shlibpath_var=no
+      hardcode_libdir_flag_spec='${wl}-R,$libdir'
+      hardcode_libdir_separator=':'
+      link_all_deplibs=yes
+      export_dynamic_flag_spec='${wl}-Bexport'
+      runpath_var='LD_RUN_PATH'
+
+      if test "$GCC" = yes; then
+	archive_cmds='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      fi
+      ;;
+
+    uts4*)
+      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_shlibpath_var=no
+      ;;
+
+    *)
+      ld_shlibs=no
+      ;;
+    esac
+
+    if test x$host_vendor = xsni; then
+      case $host in
+      sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
+	export_dynamic_flag_spec='${wl}-Blargedynsym'
+	;;
+      esac
+    fi
+  fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs" >&5
+$as_echo "$ld_shlibs" >&6; }
+test "$ld_shlibs" = no && can_build_shared=no
+
+with_gnu_ld=$with_gnu_ld
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#
+# Do we need to explicitly link libc?
+#
+case "x$archive_cmds_need_lc" in
+x|xyes)
+  # Assume -lc should be added
+  archive_cmds_need_lc=yes
+
+  if test "$enable_shared" = yes && test "$GCC" = yes; then
+    case $archive_cmds in
+    *'~'*)
+      # FIXME: we may have to deal with multi-command sequences.
+      ;;
+    '$CC '*)
+      # Test whether the compiler implicitly links with -lc since on some
+      # systems, -lgcc has to come before -lc. If gcc already passes -lc
+      # to ld, don't add -lc before -lgcc.
+      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5
+$as_echo_n "checking whether -lc should be explicitly linked in... " >&6; }
+if test "${lt_cv_archive_cmds_need_lc+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  $RM conftest*
+	echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+	if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } 2>conftest.err; then
+	  soname=conftest
+	  lib=conftest
+	  libobjs=conftest.$ac_objext
+	  deplibs=
+	  wl=$lt_prog_compiler_wl
+	  pic_flag=$lt_prog_compiler_pic
+	  compiler_flags=-v
+	  linker_flags=-v
+	  verstring=
+	  output_objdir=.
+	  libname=conftest
+	  lt_save_allow_undefined_flag=$allow_undefined_flag
+	  allow_undefined_flag=
+	  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\""; } >&5
+  (eval $archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+	  then
+	    lt_cv_archive_cmds_need_lc=no
+	  else
+	    lt_cv_archive_cmds_need_lc=yes
+	  fi
+	  allow_undefined_flag=$lt_save_allow_undefined_flag
+	else
+	  cat conftest.err 1>&5
+	fi
+	$RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc" >&5
+$as_echo "$lt_cv_archive_cmds_need_lc" >&6; }
+      archive_cmds_need_lc=$lt_cv_archive_cmds_need_lc
+      ;;
+    esac
+  fi
+  ;;
+esac
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5
+$as_echo_n "checking dynamic linker characteristics... " >&6; }
+
+if test "$GCC" = yes; then
+  case $host_os in
+    darwin*) lt_awk_arg="/^libraries:/,/LR/" ;;
+    *) lt_awk_arg="/^libraries:/" ;;
+  esac
+  case $host_os in
+    mingw* | cegcc*) lt_sed_strip_eq="s,=\([A-Za-z]:\),\1,g" ;;
+    *) lt_sed_strip_eq="s,=/,/,g" ;;
+  esac
+  lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq`
+  case $lt_search_path_spec in
+  *\;*)
+    # if the path contains ";" then we assume it to be the separator
+    # otherwise default to the standard path separator (i.e. ":") - it is
+    # assumed that no part of a normal pathname contains ";" but that should
+    # okay in the real world where ";" in dirpaths is itself problematic.
+    lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED 's/;/ /g'`
+    ;;
+  *)
+    lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED "s/$PATH_SEPARATOR/ /g"`
+    ;;
+  esac
+  # Ok, now we have the path, separated by spaces, we can step through it
+  # and add multilib dir if necessary.
+  lt_tmp_lt_search_path_spec=
+  lt_multi_os_dir=`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null`
+  for lt_sys_path in $lt_search_path_spec; do
+    if test -d "$lt_sys_path/$lt_multi_os_dir"; then
+      lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path/$lt_multi_os_dir"
+    else
+      test -d "$lt_sys_path" && \
+	lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path"
+    fi
+  done
+  lt_search_path_spec=`$ECHO "$lt_tmp_lt_search_path_spec" | awk '
+BEGIN {RS=" "; FS="/|\n";} {
+  lt_foo="";
+  lt_count=0;
+  for (lt_i = NF; lt_i > 0; lt_i--) {
+    if ($lt_i != "" && $lt_i != ".") {
+      if ($lt_i == "..") {
+        lt_count++;
+      } else {
+        if (lt_count == 0) {
+          lt_foo="/" $lt_i lt_foo;
+        } else {
+          lt_count--;
+        }
+      }
+    }
+  }
+  if (lt_foo != "") { lt_freq[lt_foo]++; }
+  if (lt_freq[lt_foo] == 1) { print lt_foo; }
+}'`
+  # AWK program above erroneously prepends '/' to C:/dos/paths
+  # for these hosts.
+  case $host_os in
+    mingw* | cegcc*) lt_search_path_spec=`$ECHO "$lt_search_path_spec" |\
+      $SED 's,/\([A-Za-z]:\),\1,g'` ;;
+  esac
+  sys_lib_search_path_spec=`$ECHO "$lt_search_path_spec" | $lt_NL2SP`
+else
+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+fi
+library_names_spec=
+libname_spec='lib$name'
+soname_spec=
+shrext_cmds=".so"
+postinstall_cmds=
+postuninstall_cmds=
+finish_cmds=
+finish_eval=
+shlibpath_var=
+shlibpath_overrides_runpath=unknown
+version_type=none
+dynamic_linker="$host_os ld.so"
+sys_lib_dlsearch_path_spec="/lib /usr/lib"
+need_lib_prefix=unknown
+hardcode_into_libs=no
+
+# when you set need_version to no, make sure it does not cause -set_version
+# flags to be left without arguments
+need_version=unknown
+
+case $host_os in
+aix3*)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'
+  shlibpath_var=LIBPATH
+
+  # AIX 3 has no versioning support, so we append a major version to the name.
+  soname_spec='${libname}${release}${shared_ext}$major'
+  ;;
+
+aix[4-9]*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  hardcode_into_libs=yes
+  if test "$host_cpu" = ia64; then
+    # AIX 5 supports IA64
+    library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'
+    shlibpath_var=LD_LIBRARY_PATH
+  else
+    # With GCC up to 2.95.x, collect2 would create an import file
+    # for dependence libraries.  The import file would start with
+    # the line `#! .'.  This would cause the generated library to
+    # depend on `.', always an invalid library.  This was fixed in
+    # development snapshots of GCC prior to 3.0.
+    case $host_os in
+      aix4 | aix4.[01] | aix4.[01].*)
+      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
+	   echo ' yes '
+	   echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then
+	:
+      else
+	can_build_shared=no
+      fi
+      ;;
+    esac
+    # AIX (on Power*) has no versioning support, so currently we can not hardcode correct
+    # soname into executable. Probably we can add versioning support to
+    # collect2, so additional links can be useful in future.
+    if test "$aix_use_runtimelinking" = yes; then
+      # If using run time linking (on AIX 4.2 or later) use lib<name>.so
+      # instead of lib<name>.a to let people know that these are not
+      # typical AIX shared libraries.
+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    else
+      # We preserve .a as extension for shared libraries through AIX4.2
+      # and later when we are not doing run time linking.
+      library_names_spec='${libname}${release}.a $libname.a'
+      soname_spec='${libname}${release}${shared_ext}$major'
+    fi
+    shlibpath_var=LIBPATH
+  fi
+  ;;
+
+amigaos*)
+  case $host_cpu in
+  powerpc)
+    # Since July 2007 AmigaOS4 officially supports .so libraries.
+    # When compiling the executable, add -use-dynld -Lsobjs: to the compileline.
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    ;;
+  m68k)
+    library_names_spec='$libname.ixlibrary $libname.a'
+    # Create ${libname}_ixlibrary.a entries in /sys/libs.
+    finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
+    ;;
+  esac
+  ;;
+
+beos*)
+  library_names_spec='${libname}${shared_ext}'
+  dynamic_linker="$host_os ld.so"
+  shlibpath_var=LIBRARY_PATH
+  ;;
+
+bsdi[45]*)
+  version_type=linux
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
+  # the default ld.so.conf also contains /usr/contrib/lib and
+  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
+  # libtool to hard-code these into programs
+  ;;
+
+cygwin* | mingw* | pw32* | cegcc*)
+  version_type=windows
+  shrext_cmds=".dll"
+  need_version=no
+  need_lib_prefix=no
+
+  case $GCC,$host_os in
+  yes,cygwin* | yes,mingw* | yes,pw32* | yes,cegcc*)
+    library_names_spec='$libname.dll.a'
+    # DLL is installed to $(libdir)/../bin by postinstall_cmds
+    postinstall_cmds='base_file=`basename \${file}`~
+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~
+      dldir=$destdir/`dirname \$dlpath`~
+      test -d \$dldir || mkdir -p \$dldir~
+      $install_prog $dir/$dlname \$dldir/$dlname~
+      chmod a+x \$dldir/$dlname~
+      if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
+        eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
+      fi'
+    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
+      dlpath=$dir/\$dldll~
+       $RM \$dlpath'
+    shlibpath_overrides_runpath=yes
+
+    case $host_os in
+    cygwin*)
+      # Cygwin DLLs use 'cyg' prefix rather than 'lib'
+      soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
+
+      sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api"
+      ;;
+    mingw* | cegcc*)
+      # MinGW DLLs use traditional 'lib' prefix
+      soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
+      ;;
+    pw32*)
+      # pw32 DLLs use 'pw' prefix rather than 'lib'
+      library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
+      ;;
+    esac
+    ;;
+
+  *)
+    library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib'
+    ;;
+  esac
+  dynamic_linker='Win32 ld.exe'
+  # FIXME: first we should search . and the directory the executable is in
+  shlibpath_var=PATH
+  ;;
+
+darwin* | rhapsody*)
+  dynamic_linker="$host_os dyld"
+  version_type=darwin
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext'
+  soname_spec='${libname}${release}${major}$shared_ext'
+  shlibpath_overrides_runpath=yes
+  shlibpath_var=DYLD_LIBRARY_PATH
+  shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'
+
+  sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/local/lib"
+  sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
+  ;;
+
+dgux*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+freebsd* | dragonfly*)
+  # DragonFly does not have aout.  When/if they implement a new
+  # versioning mechanism, adjust this.
+  if test -x /usr/bin/objformat; then
+    objformat=`/usr/bin/objformat`
+  else
+    case $host_os in
+    freebsd[23].*) objformat=aout ;;
+    *) objformat=elf ;;
+    esac
+  fi
+  version_type=freebsd-$objformat
+  case $version_type in
+    freebsd-elf*)
+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
+      need_version=no
+      need_lib_prefix=no
+      ;;
+    freebsd-*)
+      library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'
+      need_version=yes
+      ;;
+  esac
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_os in
+  freebsd2.*)
+    shlibpath_overrides_runpath=yes
+    ;;
+  freebsd3.[01]* | freebsdelf3.[01]*)
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  freebsd3.[2-9]* | freebsdelf3.[2-9]* | \
+  freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1)
+    shlibpath_overrides_runpath=no
+    hardcode_into_libs=yes
+    ;;
+  *) # from 4.6 on, and DragonFly
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  esac
+  ;;
+
+gnu*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  hardcode_into_libs=yes
+  ;;
+
+haiku*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  dynamic_linker="$host_os runtime_loader"
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/beos/system/lib'
+  hardcode_into_libs=yes
+  ;;
+
+hpux9* | hpux10* | hpux11*)
+  # Give a soname corresponding to the major version so that dld.sl refuses to
+  # link against other versions.
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  case $host_cpu in
+  ia64*)
+    shrext_cmds='.so'
+    hardcode_into_libs=yes
+    dynamic_linker="$host_os dld.so"
+    shlibpath_var=LD_LIBRARY_PATH
+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    soname_spec='${libname}${release}${shared_ext}$major'
+    if test "X$HPUX_IA64_MODE" = X32; then
+      sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
+    else
+      sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
+    fi
+    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+    ;;
+  hppa*64*)
+    shrext_cmds='.sl'
+    hardcode_into_libs=yes
+    dynamic_linker="$host_os dld.sl"
+    shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    soname_spec='${libname}${release}${shared_ext}$major'
+    sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
+    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+    ;;
+  *)
+    shrext_cmds='.sl'
+    dynamic_linker="$host_os dld.sl"
+    shlibpath_var=SHLIB_PATH
+    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    soname_spec='${libname}${release}${shared_ext}$major'
+    ;;
+  esac
+  # HP-UX runs *really* slowly unless shared libraries are mode 555, ...
+  postinstall_cmds='chmod 555 $lib'
+  # or fails outright, so override atomically:
+  install_override_mode=555
+  ;;
+
+interix[3-9]*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  ;;
+
+irix5* | irix6* | nonstopux*)
+  case $host_os in
+    nonstopux*) version_type=nonstopux ;;
+    *)
+	if test "$lt_cv_prog_gnu_ld" = yes; then
+		version_type=linux
+	else
+		version_type=irix
+	fi ;;
+  esac
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'
+  case $host_os in
+  irix5* | nonstopux*)
+    libsuff= shlibsuff=
+    ;;
+  *)
+    case $LD in # libtool.m4 will add one of these switches to LD
+    *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
+      libsuff= shlibsuff= libmagic=32-bit;;
+    *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")
+      libsuff=32 shlibsuff=N32 libmagic=N32;;
+    *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")
+      libsuff=64 shlibsuff=64 libmagic=64-bit;;
+    *) libsuff= shlibsuff= libmagic=never-match;;
+    esac
+    ;;
+  esac
+  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
+  shlibpath_overrides_runpath=no
+  sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"
+  sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"
+  hardcode_into_libs=yes
+  ;;
+
+# No shared lib support for Linux oldld, aout, or coff.
+linux*oldld* | linux*aout* | linux*coff*)
+  dynamic_linker=no
+  ;;
+
+# This must be Linux ELF.
+linux* | k*bsd*-gnu | kopensolaris*-gnu)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+
+  # Some binutils ld are patched to set DT_RUNPATH
+  if test "${lt_cv_shlibpath_overrides_runpath+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_shlibpath_overrides_runpath=no
+    save_LDFLAGS=$LDFLAGS
+    save_libdir=$libdir
+    eval "libdir=/foo; wl=\"$lt_prog_compiler_wl\"; \
+	 LDFLAGS=\"\$LDFLAGS $hardcode_libdir_flag_spec\""
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  if  ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null; then :
+  lt_cv_shlibpath_overrides_runpath=yes
+fi
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+    LDFLAGS=$save_LDFLAGS
+    libdir=$save_libdir
+
+fi
+
+  shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath
+
+  # This implies no fast_install, which is unacceptable.
+  # Some rework will be needed to allow for fast_install
+  # before this can be enabled.
+  hardcode_into_libs=yes
+
+  # Append ld.so.conf contents to the search path
+  if test -f /etc/ld.so.conf; then
+    lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[	 ]*hwcap[	 ]/d;s/[:,	]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '`
+    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
+  fi
+
+  # We used to test for /lib/ld.so.1 and disable shared libraries on
+  # powerpc, because MkLinux only supported shared libraries with the
+  # GNU dynamic linker.  Since this was broken with cross compilers,
+  # most powerpc-linux boxes support dynamic linking these days and
+  # people can always --disable-shared, the test was removed, and we
+  # assume the GNU/Linux dynamic linker is in use.
+  dynamic_linker='GNU/Linux ld.so'
+  ;;
+
+netbsd*)
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+    dynamic_linker='NetBSD (a.out) ld.so'
+  else
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+    soname_spec='${libname}${release}${shared_ext}$major'
+    dynamic_linker='NetBSD ld.elf_so'
+  fi
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  ;;
+
+newsos6)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  ;;
+
+*nto* | *qnx*)
+  version_type=qnx
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='ldqnx.so'
+  ;;
+
+openbsd*)
+  version_type=sunos
+  sys_lib_dlsearch_path_spec="/usr/lib"
+  need_lib_prefix=no
+  # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs.
+  case $host_os in
+    openbsd3.3 | openbsd3.3.*)	need_version=yes ;;
+    *)				need_version=no  ;;
+  esac
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+    case $host_os in
+      openbsd2.[89] | openbsd2.[89].*)
+	shlibpath_overrides_runpath=no
+	;;
+      *)
+	shlibpath_overrides_runpath=yes
+	;;
+      esac
+  else
+    shlibpath_overrides_runpath=yes
+  fi
+  ;;
+
+os2*)
+  libname_spec='$name'
+  shrext_cmds=".dll"
+  need_lib_prefix=no
+  library_names_spec='$libname${shared_ext} $libname.a'
+  dynamic_linker='OS/2 ld.exe'
+  shlibpath_var=LIBPATH
+  ;;
+
+osf3* | osf4* | osf5*)
+  version_type=osf
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
+  sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"
+  ;;
+
+rdos*)
+  dynamic_linker=no
+  ;;
+
+solaris*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  # ldd complains unless libraries are executable
+  postinstall_cmds='chmod +x $lib'
+  ;;
+
+sunos4*)
+  version_type=sunos
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  if test "$with_gnu_ld" = yes; then
+    need_lib_prefix=no
+  fi
+  need_version=yes
+  ;;
+
+sysv4 | sysv4.3*)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_vendor in
+    sni)
+      shlibpath_overrides_runpath=no
+      need_lib_prefix=no
+      runpath_var=LD_RUN_PATH
+      ;;
+    siemens)
+      need_lib_prefix=no
+      ;;
+    motorola)
+      need_lib_prefix=no
+      need_version=no
+      shlibpath_overrides_runpath=no
+      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
+      ;;
+  esac
+  ;;
+
+sysv4*MP*)
+  if test -d /usr/nec ;then
+    version_type=linux
+    library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'
+    soname_spec='$libname${shared_ext}.$major'
+    shlibpath_var=LD_LIBRARY_PATH
+  fi
+  ;;
+
+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+  version_type=freebsd-elf
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  if test "$with_gnu_ld" = yes; then
+    sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
+  else
+    sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
+    case $host_os in
+      sco3.2v5*)
+        sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"
+	;;
+    esac
+  fi
+  sys_lib_dlsearch_path_spec='/usr/lib'
+  ;;
+
+tpf*)
+  # TPF is a cross-target only.  Preferred cross-host = GNU/Linux.
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  ;;
+
+uts4*)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+*)
+  dynamic_linker=no
+  ;;
+esac
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5
+$as_echo "$dynamic_linker" >&6; }
+test "$dynamic_linker" = no && can_build_shared=no
+
+variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
+if test "$GCC" = yes; then
+  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
+fi
+
+if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then
+  sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec"
+fi
+if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then
+  sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec"
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5
+$as_echo_n "checking how to hardcode library paths into programs... " >&6; }
+hardcode_action=
+if test -n "$hardcode_libdir_flag_spec" ||
+   test -n "$runpath_var" ||
+   test "X$hardcode_automatic" = "Xyes" ; then
+
+  # We can hardcode non-existent directories.
+  if test "$hardcode_direct" != no &&
+     # If the only mechanism to avoid hardcoding is shlibpath_var, we
+     # have to relink, otherwise we might link with an installed library
+     # when we should be linking with a yet-to-be-installed one
+     ## test "$_LT_TAGVAR(hardcode_shlibpath_var, )" != no &&
+     test "$hardcode_minus_L" != no; then
+    # Linking always hardcodes the temporary library directory.
+    hardcode_action=relink
+  else
+    # We can link without hardcoding, and we can hardcode nonexisting dirs.
+    hardcode_action=immediate
+  fi
+else
+  # We cannot hardcode anything, or else we can only hardcode existing
+  # directories.
+  hardcode_action=unsupported
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action" >&5
+$as_echo "$hardcode_action" >&6; }
+
+if test "$hardcode_action" = relink ||
+   test "$inherit_rpath" = yes; then
+  # Fast installation is not supported
+  enable_fast_install=no
+elif test "$shlibpath_overrides_runpath" = yes ||
+     test "$enable_shared" = no; then
+  # Fast installation is not necessary
+  enable_fast_install=needless
+fi
+
+
+
+
+
+
+  if test "x$enable_dlopen" != xyes; then
+  enable_dlopen=unknown
+  enable_dlopen_self=unknown
+  enable_dlopen_self_static=unknown
+else
+  lt_cv_dlopen=no
+  lt_cv_dlopen_libs=
+
+  case $host_os in
+  beos*)
+    lt_cv_dlopen="load_add_on"
+    lt_cv_dlopen_libs=
+    lt_cv_dlopen_self=yes
+    ;;
+
+  mingw* | pw32* | cegcc*)
+    lt_cv_dlopen="LoadLibrary"
+    lt_cv_dlopen_libs=
+    ;;
+
+  cygwin*)
+    lt_cv_dlopen="dlopen"
+    lt_cv_dlopen_libs=
+    ;;
+
+  darwin*)
+  # if libdl is installed we need to link against it
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
+$as_echo_n "checking for dlopen in -ldl... " >&6; }
+if test "${ac_cv_lib_dl_dlopen+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldl  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char dlopen ();
+int
+main ()
+{
+return dlopen ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_dl_dlopen=yes
+else
+  ac_cv_lib_dl_dlopen=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
+$as_echo "$ac_cv_lib_dl_dlopen" >&6; }
+if test "x$ac_cv_lib_dl_dlopen" = x""yes; then :
+  lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"
+else
+
+    lt_cv_dlopen="dyld"
+    lt_cv_dlopen_libs=
+    lt_cv_dlopen_self=yes
+
+fi
+
+    ;;
+
+  *)
+    ac_fn_c_check_func "$LINENO" "shl_load" "ac_cv_func_shl_load"
+if test "x$ac_cv_func_shl_load" = x""yes; then :
+  lt_cv_dlopen="shl_load"
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5
+$as_echo_n "checking for shl_load in -ldld... " >&6; }
+if test "${ac_cv_lib_dld_shl_load+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldld  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char shl_load ();
+int
+main ()
+{
+return shl_load ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_dld_shl_load=yes
+else
+  ac_cv_lib_dld_shl_load=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5
+$as_echo "$ac_cv_lib_dld_shl_load" >&6; }
+if test "x$ac_cv_lib_dld_shl_load" = x""yes; then :
+  lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-ldld"
+else
+  ac_fn_c_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen"
+if test "x$ac_cv_func_dlopen" = x""yes; then :
+  lt_cv_dlopen="dlopen"
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
+$as_echo_n "checking for dlopen in -ldl... " >&6; }
+if test "${ac_cv_lib_dl_dlopen+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldl  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char dlopen ();
+int
+main ()
+{
+return dlopen ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_dl_dlopen=yes
+else
+  ac_cv_lib_dl_dlopen=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
+$as_echo "$ac_cv_lib_dl_dlopen" >&6; }
+if test "x$ac_cv_lib_dl_dlopen" = x""yes; then :
+  lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5
+$as_echo_n "checking for dlopen in -lsvld... " >&6; }
+if test "${ac_cv_lib_svld_dlopen+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lsvld  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char dlopen ();
+int
+main ()
+{
+return dlopen ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_svld_dlopen=yes
+else
+  ac_cv_lib_svld_dlopen=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5
+$as_echo "$ac_cv_lib_svld_dlopen" >&6; }
+if test "x$ac_cv_lib_svld_dlopen" = x""yes; then :
+  lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5
+$as_echo_n "checking for dld_link in -ldld... " >&6; }
+if test "${ac_cv_lib_dld_dld_link+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldld  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char dld_link ();
+int
+main ()
+{
+return dld_link ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_dld_dld_link=yes
+else
+  ac_cv_lib_dld_dld_link=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5
+$as_echo "$ac_cv_lib_dld_dld_link" >&6; }
+if test "x$ac_cv_lib_dld_dld_link" = x""yes; then :
+  lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-ldld"
+fi
+
+
+fi
+
+
+fi
+
+
+fi
+
+
+fi
+
+
+fi
+
+    ;;
+  esac
+
+  if test "x$lt_cv_dlopen" != xno; then
+    enable_dlopen=yes
+  else
+    enable_dlopen=no
+  fi
+
+  case $lt_cv_dlopen in
+  dlopen)
+    save_CPPFLAGS="$CPPFLAGS"
+    test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"
+
+    save_LDFLAGS="$LDFLAGS"
+    wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"
+
+    save_LIBS="$LIBS"
+    LIBS="$lt_cv_dlopen_libs $LIBS"
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5
+$as_echo_n "checking whether a program can dlopen itself... " >&6; }
+if test "${lt_cv_dlopen_self+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  	  if test "$cross_compiling" = yes; then :
+  lt_cv_dlopen_self=cross
+else
+  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
+  lt_status=$lt_dlunknown
+  cat > conftest.$ac_ext <<_LT_EOF
+#line 10634 "configure"
+#include "confdefs.h"
+
+#if HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+
+#include <stdio.h>
+
+#ifdef RTLD_GLOBAL
+#  define LT_DLGLOBAL		RTLD_GLOBAL
+#else
+#  ifdef DL_GLOBAL
+#    define LT_DLGLOBAL		DL_GLOBAL
+#  else
+#    define LT_DLGLOBAL		0
+#  endif
+#endif
+
+/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
+   find out it does not work in some platform. */
+#ifndef LT_DLLAZY_OR_NOW
+#  ifdef RTLD_LAZY
+#    define LT_DLLAZY_OR_NOW		RTLD_LAZY
+#  else
+#    ifdef DL_LAZY
+#      define LT_DLLAZY_OR_NOW		DL_LAZY
+#    else
+#      ifdef RTLD_NOW
+#        define LT_DLLAZY_OR_NOW	RTLD_NOW
+#      else
+#        ifdef DL_NOW
+#          define LT_DLLAZY_OR_NOW	DL_NOW
+#        else
+#          define LT_DLLAZY_OR_NOW	0
+#        endif
+#      endif
+#    endif
+#  endif
+#endif
+
+/* When -fvisbility=hidden is used, assume the code has been annotated
+   correspondingly for the symbols needed.  */
+#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
+void fnord () __attribute__((visibility("default")));
+#endif
+
+void fnord () { int i=42; }
+int main ()
+{
+  void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
+  int status = $lt_dlunknown;
+
+  if (self)
+    {
+      if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;
+      else
+        {
+	  if (dlsym( self,"_fnord"))  status = $lt_dlneed_uscore;
+          else puts (dlerror ());
+	}
+      /* dlclose (self); */
+    }
+  else
+    puts (dlerror ());
+
+  return status;
+}
+_LT_EOF
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
+  (eval $ac_link) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then
+    (./conftest; exit; ) >&5 2>/dev/null
+    lt_status=$?
+    case x$lt_status in
+      x$lt_dlno_uscore) lt_cv_dlopen_self=yes ;;
+      x$lt_dlneed_uscore) lt_cv_dlopen_self=yes ;;
+      x$lt_dlunknown|x*) lt_cv_dlopen_self=no ;;
+    esac
+  else :
+    # compilation failed
+    lt_cv_dlopen_self=no
+  fi
+fi
+rm -fr conftest*
+
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5
+$as_echo "$lt_cv_dlopen_self" >&6; }
+
+    if test "x$lt_cv_dlopen_self" = xyes; then
+      wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\"
+      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5
+$as_echo_n "checking whether a statically linked program can dlopen itself... " >&6; }
+if test "${lt_cv_dlopen_self_static+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  	  if test "$cross_compiling" = yes; then :
+  lt_cv_dlopen_self_static=cross
+else
+  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
+  lt_status=$lt_dlunknown
+  cat > conftest.$ac_ext <<_LT_EOF
+#line 10740 "configure"
+#include "confdefs.h"
+
+#if HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+
+#include <stdio.h>
+
+#ifdef RTLD_GLOBAL
+#  define LT_DLGLOBAL		RTLD_GLOBAL
+#else
+#  ifdef DL_GLOBAL
+#    define LT_DLGLOBAL		DL_GLOBAL
+#  else
+#    define LT_DLGLOBAL		0
+#  endif
+#endif
+
+/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
+   find out it does not work in some platform. */
+#ifndef LT_DLLAZY_OR_NOW
+#  ifdef RTLD_LAZY
+#    define LT_DLLAZY_OR_NOW		RTLD_LAZY
+#  else
+#    ifdef DL_LAZY
+#      define LT_DLLAZY_OR_NOW		DL_LAZY
+#    else
+#      ifdef RTLD_NOW
+#        define LT_DLLAZY_OR_NOW	RTLD_NOW
+#      else
+#        ifdef DL_NOW
+#          define LT_DLLAZY_OR_NOW	DL_NOW
+#        else
+#          define LT_DLLAZY_OR_NOW	0
+#        endif
+#      endif
+#    endif
+#  endif
+#endif
+
+/* When -fvisbility=hidden is used, assume the code has been annotated
+   correspondingly for the symbols needed.  */
+#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
+void fnord () __attribute__((visibility("default")));
+#endif
+
+void fnord () { int i=42; }
+int main ()
+{
+  void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
+  int status = $lt_dlunknown;
+
+  if (self)
+    {
+      if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;
+      else
+        {
+	  if (dlsym( self,"_fnord"))  status = $lt_dlneed_uscore;
+          else puts (dlerror ());
+	}
+      /* dlclose (self); */
+    }
+  else
+    puts (dlerror ());
+
+  return status;
+}
+_LT_EOF
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
+  (eval $ac_link) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then
+    (./conftest; exit; ) >&5 2>/dev/null
+    lt_status=$?
+    case x$lt_status in
+      x$lt_dlno_uscore) lt_cv_dlopen_self_static=yes ;;
+      x$lt_dlneed_uscore) lt_cv_dlopen_self_static=yes ;;
+      x$lt_dlunknown|x*) lt_cv_dlopen_self_static=no ;;
+    esac
+  else :
+    # compilation failed
+    lt_cv_dlopen_self_static=no
+  fi
+fi
+rm -fr conftest*
+
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static" >&5
+$as_echo "$lt_cv_dlopen_self_static" >&6; }
+    fi
+
+    CPPFLAGS="$save_CPPFLAGS"
+    LDFLAGS="$save_LDFLAGS"
+    LIBS="$save_LIBS"
+    ;;
+  esac
+
+  case $lt_cv_dlopen_self in
+  yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;;
+  *) enable_dlopen_self=unknown ;;
+  esac
+
+  case $lt_cv_dlopen_self_static in
+  yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;;
+  *) enable_dlopen_self_static=unknown ;;
+  esac
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+striplib=
+old_striplib=
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5
+$as_echo_n "checking whether stripping libraries is possible... " >&6; }
+if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then
+  test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"
+  test -z "$striplib" && striplib="$STRIP --strip-unneeded"
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+else
+# FIXME - insert some real tests, host_os isn't really good enough
+  case $host_os in
+  darwin*)
+    if test -n "$STRIP" ; then
+      striplib="$STRIP -x"
+      old_striplib="$STRIP -S"
+      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+    else
+      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+    fi
+    ;;
+  *)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+    ;;
+  esac
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+  # Report which library types will actually be built
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if libtool supports shared libraries" >&5
+$as_echo_n "checking if libtool supports shared libraries... " >&6; }
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $can_build_shared" >&5
+$as_echo "$can_build_shared" >&6; }
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries" >&5
+$as_echo_n "checking whether to build shared libraries... " >&6; }
+  test "$can_build_shared" = "no" && enable_shared=no
+
+  # On AIX, shared libraries and static libraries use the same namespace, and
+  # are all built from PIC.
+  case $host_os in
+  aix3*)
+    test "$enable_shared" = yes && enable_static=no
+    if test -n "$RANLIB"; then
+      archive_cmds="$archive_cmds~\$RANLIB \$lib"
+      postinstall_cmds='$RANLIB $lib'
+    fi
+    ;;
+
+  aix[4-9]*)
+    if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
+      test "$enable_shared" = yes && enable_static=no
+    fi
+    ;;
+  esac
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_shared" >&5
+$as_echo "$enable_shared" >&6; }
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build static libraries" >&5
+$as_echo_n "checking whether to build static libraries... " >&6; }
+  # Make sure either enable_shared or enable_static is yes.
+  test "$enable_shared" = yes || enable_static=yes
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_static" >&5
+$as_echo "$enable_static" >&6; }
+
+
+
+
+fi
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+CC="$lt_save_CC"
+
+
+
+
+
+
+
+
+
+
+
+
+
+        ac_config_commands="$ac_config_commands libtool"
+
+
+
+
+# Only expand once:
+
+
+libtool_VERSION=1:0:0
+
+
+# Checks for libraries.
+# Checks for header files.
+for ac_header in stdlib.h
+do :
+  ac_fn_c_check_header_mongrel "$LINENO" "stdlib.h" "ac_cv_header_stdlib_h" "$ac_includes_default"
+if test "x$ac_cv_header_stdlib_h" = x""yes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_STDLIB_H 1
+_ACEOF
+
+fi
+
+done
+
+if test "x$THREADS" == xposix ; then
+for ac_header in pthread.h
+do :
+  ac_fn_c_check_header_mongrel "$LINENO" "pthread.h" "ac_cv_header_pthread_h" "$ac_includes_default"
+if test "x$ac_cv_header_pthread_h" = x""yes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_PTHREAD_H 1
+_ACEOF
+
+fi
+
+done
+
+fi
+
+# Checks for typedefs, structures, and compiler characteristics.
+ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default"
+if test "x$ac_cv_type_size_t" = x""yes; then :
+
+else
+
+cat >>confdefs.h <<_ACEOF
+#define size_t unsigned int
+_ACEOF
+
+fi
+
+
+# Checks for library functions.
+for ac_header in stdlib.h
+do :
+  ac_fn_c_check_header_mongrel "$LINENO" "stdlib.h" "ac_cv_header_stdlib_h" "$ac_includes_default"
+if test "x$ac_cv_header_stdlib_h" = x""yes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_STDLIB_H 1
+_ACEOF
+
+fi
+
+done
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU libc compatible malloc" >&5
+$as_echo_n "checking for GNU libc compatible malloc... " >&6; }
+if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test "$cross_compiling" = yes; then :
+  ac_cv_func_malloc_0_nonnull=no
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#if defined STDC_HEADERS || defined HAVE_STDLIB_H
+# include <stdlib.h>
+#else
+char *malloc ();
+#endif
+
+int
+main ()
+{
+return ! malloc (0);
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+  ac_cv_func_malloc_0_nonnull=yes
+else
+  ac_cv_func_malloc_0_nonnull=no
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_malloc_0_nonnull" >&5
+$as_echo "$ac_cv_func_malloc_0_nonnull" >&6; }
+if test $ac_cv_func_malloc_0_nonnull = yes; then :
+
+$as_echo "#define HAVE_MALLOC 1" >>confdefs.h
+
+else
+  $as_echo "#define HAVE_MALLOC 0" >>confdefs.h
+
+   case " $LIBOBJS " in
+  *" malloc.$ac_objext "* ) ;;
+  *) LIBOBJS="$LIBOBJS malloc.$ac_objext"
+ ;;
+esac
+
+
+$as_echo "#define malloc rpl_malloc" >>confdefs.h
+
+fi
+
+
+
+save_CFLAGS="$CFLAGS"
+
+CFLAGS="$CFLAGS -I$openclinc"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#if __CYGWIN__ && !_WIN32
+   #define _WIN32 1
+   #endif
+   #ifdef MAC
+   #include <OpenCL/cl.h>
+   #else
+   #include <CL/cl.h>
+   #endif
+
+int
+main ()
+{
+cl_platform_id platform; clGetPlatformIDs(1, &platform, NULL);
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+
+else
+  as_fn_error "OpenCL SDK must be installed to build liboacc library" "$LINENO" 5
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+
+if test "x$THREADS" == xposix ; then
+CFLAGS="$CFLAGS -pthread"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <pthread.h>
+     void *f(void *d) { return NULL; }
+int
+main ()
+{
+pthread_t t; pthread_create(&t,NULL,f,NULL);
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+
+else
+  as_fn_error "Compiler configured to use posix threads but header file is missing" "$LINENO" 5
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+
+CFLAGS="$save_CFLAGS"
+ac_config_headers="$ac_config_headers config.h"
+
+ac_config_files="$ac_config_files Makefile liboacc.spec"
+
+cat >confcache <<\_ACEOF
+# This file is a shell script that caches the results of configure
+# tests run on this system so they can be shared between configure
+# scripts and configure runs, see configure's option --config-cache.
+# It is not useful on other systems.  If it contains results you don't
+# want to keep, you may remove or edit it.
+#
+# config.status only pays attention to the cache file if you give it
+# the --recheck option to rerun configure.
+#
+# `ac_cv_env_foo' variables (set or unset) will be overridden when
+# loading this file, other *unset* `ac_cv_foo' will be assigned the
+# following values.
+
+_ACEOF
+
+# The following way of writing the cache mishandles newlines in values,
+# but we know of no workaround that is simple, portable, and efficient.
+# So, we kill variables containing newlines.
+# Ultrix sh set writes to stderr and can't be redirected directly,
+# and sets the high bit in the cache file unless we assign to the vars.
+(
+  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
+    eval ac_val=\$$ac_var
+    case $ac_val in #(
+    *${as_nl}*)
+      case $ac_var in #(
+      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
+$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+      esac
+      case $ac_var in #(
+      _ | IFS | as_nl) ;; #(
+      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
+      *) { eval $ac_var=; unset $ac_var;} ;;
+      esac ;;
+    esac
+  done
+
+  (set) 2>&1 |
+    case $as_nl`(ac_space=' '; set) 2>&1` in #(
+    *${as_nl}ac_space=\ *)
+      # `set' does not quote correctly, so add quotes: double-quote
+      # substitution turns \\\\ into \\, and sed turns \\ into \.
+      sed -n \
+	"s/'/'\\\\''/g;
+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
+      ;; #(
+    *)
+      # `set' quotes correctly as required by POSIX, so do not add quotes.
+      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+      ;;
+    esac |
+    sort
+) |
+  sed '
+     /^ac_cv_env_/b end
+     t clear
+     :clear
+     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
+     t end
+     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
+     :end' >>confcache
+if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
+  if test -w "$cache_file"; then
+    test "x$cache_file" != "x/dev/null" &&
+      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
+$as_echo "$as_me: updating cache $cache_file" >&6;}
+    cat confcache >$cache_file
+  else
+    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
+$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
+  fi
+fi
+rm -f confcache
+
+test "x$prefix" = xNONE && prefix=$ac_default_prefix
+# Let make expand exec_prefix.
+test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
+
+DEFS=-DHAVE_CONFIG_H
+
+ac_libobjs=
+ac_ltlibobjs=
+for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
+  # 1. Remove the extension, and $U if already installed.
+  ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
+  ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
+  # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
+  #    will be set to the directory where LIBOBJS objects are built.
+  as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
+  as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
+done
+LIBOBJS=$ac_libobjs
+
+LTLIBOBJS=$ac_ltlibobjs
+
+
+if test -z "${GENINSRC_TRUE}" && test -z "${GENINSRC_FALSE}"; then
+  as_fn_error "conditional \"GENINSRC\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking that generated files are newer than configure" >&5
+$as_echo_n "checking that generated files are newer than configure... " >&6; }
+   if test -n "$am_sleep_pid"; then
+     # Hide warnings about reused PIDs.
+     wait $am_sleep_pid 2>/dev/null
+   fi
+   { $as_echo "$as_me:${as_lineno-$LINENO}: result: done" >&5
+$as_echo "done" >&6; }
+ if test -n "$EXEEXT"; then
+  am__EXEEXT_TRUE=
+  am__EXEEXT_FALSE='#'
+else
+  am__EXEEXT_TRUE='#'
+  am__EXEEXT_FALSE=
+fi
+
+if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
+  as_fn_error "conditional \"AMDEP\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
+  as_fn_error "conditional \"am__fastdepCC\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+
+: ${CONFIG_STATUS=./config.status}
+ac_write_fail=0
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files $CONFIG_STATUS"
+{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
+$as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
+as_write_fail=0
+cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
+#! $SHELL
+# Generated by $as_me.
+# Run this file to recreate the current configuration.
+# Compiler output produced by configure, useful for debugging
+# configure, is in config.log if it exists.
+
+debug=false
+ac_cs_recheck=false
+ac_cs_silent=false
+
+SHELL=\${CONFIG_SHELL-$SHELL}
+export SHELL
+_ASEOF
+cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
+## -------------------- ##
+## M4sh Initialization. ##
+## -------------------- ##
+
+# Be more Bourne compatible
+DUALCASE=1; export DUALCASE # for MKS sh
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+  setopt NO_GLOB_SUBST
+else
+  case `(set -o) 2>/dev/null` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+
+
+as_nl='
+'
+export as_nl
+# Printing a long string crashes Solaris 7 /usr/bin/printf.
+as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
+# Prefer a ksh shell builtin over an external printf program on Solaris,
+# but without wasting forks for bash or zsh.
+if test -z "$BASH_VERSION$ZSH_VERSION" \
+    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='print -r --'
+  as_echo_n='print -rn --'
+elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='printf %s\n'
+  as_echo_n='printf %s'
+else
+  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
+    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
+    as_echo_n='/usr/ucb/echo -n'
+  else
+    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
+    as_echo_n_body='eval
+      arg=$1;
+      case $arg in #(
+      *"$as_nl"*)
+	expr "X$arg" : "X\\(.*\\)$as_nl";
+	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
+      esac;
+      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
+    '
+    export as_echo_n_body
+    as_echo_n='sh -c $as_echo_n_body as_echo'
+  fi
+  export as_echo_body
+  as_echo='sh -c $as_echo_body as_echo'
+fi
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  PATH_SEPARATOR=:
+  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
+    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
+      PATH_SEPARATOR=';'
+  }
+fi
+
+
+# IFS
+# We need space, tab and new line, in precisely that order.  Quoting is
+# there to prevent editors from complaining about space-tab.
+# (If _AS_PATH_WALK were called with IFS unset, it would disable word
+# splitting by setting IFS to empty value.)
+IFS=" ""	$as_nl"
+
+# Find who we are.  Look in the path if we contain no directory separator.
+case $0 in #((
+  *[\\/]* ) as_myself=$0 ;;
+  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+  done
+IFS=$as_save_IFS
+
+     ;;
+esac
+# We did not find ourselves, most probably we were run as `sh COMMAND'
+# in which case we are not to be found in the path.
+if test "x$as_myself" = x; then
+  as_myself=$0
+fi
+if test ! -f "$as_myself"; then
+  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+  exit 1
+fi
+
+# Unset variables that we do not need and which cause bugs (e.g. in
+# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
+# suppresses any "Segmentation fault" message there.  '((' could
+# trigger a bug in pdksh 5.2.14.
+for as_var in BASH_ENV ENV MAIL MAILPATH
+do eval test x\${$as_var+set} = xset \
+  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
+done
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# NLS nuisances.
+LC_ALL=C
+export LC_ALL
+LANGUAGE=C
+export LANGUAGE
+
+# CDPATH.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+
+# as_fn_error ERROR [LINENO LOG_FD]
+# ---------------------------------
+# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
+# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
+# script with status $?, using 1 if that was 0.
+as_fn_error ()
+{
+  as_status=$?; test $as_status -eq 0 && as_status=1
+  if test "$3"; then
+    as_lineno=${as_lineno-"$2"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+    $as_echo "$as_me:${as_lineno-$LINENO}: error: $1" >&$3
+  fi
+  $as_echo "$as_me: error: $1" >&2
+  as_fn_exit $as_status
+} # as_fn_error
+
+
+# as_fn_set_status STATUS
+# -----------------------
+# Set $? to STATUS, without forking.
+as_fn_set_status ()
+{
+  return $1
+} # as_fn_set_status
+
+# as_fn_exit STATUS
+# -----------------
+# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
+as_fn_exit ()
+{
+  set +e
+  as_fn_set_status $1
+  exit $1
+} # as_fn_exit
+
+# as_fn_unset VAR
+# ---------------
+# Portably unset VAR.
+as_fn_unset ()
+{
+  { eval $1=; unset $1;}
+}
+as_unset=as_fn_unset
+# as_fn_append VAR VALUE
+# ----------------------
+# Append the text in VALUE to the end of the definition contained in VAR. Take
+# advantage of any shell optimizations that allow amortized linear growth over
+# repeated appends, instead of the typical quadratic growth present in naive
+# implementations.
+if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
+  eval 'as_fn_append ()
+  {
+    eval $1+=\$2
+  }'
+else
+  as_fn_append ()
+  {
+    eval $1=\$$1\$2
+  }
+fi # as_fn_append
+
+# as_fn_arith ARG...
+# ------------------
+# Perform arithmetic evaluation on the ARGs, and store the result in the
+# global $as_val. Take advantage of shells that can avoid forks. The arguments
+# must be portable across $(()) and expr.
+if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
+  eval 'as_fn_arith ()
+  {
+    as_val=$(( $* ))
+  }'
+else
+  as_fn_arith ()
+  {
+    as_val=`expr "$@" || test $? -eq 1`
+  }
+fi # as_fn_arith
+
+
+if expr a : '\(a\)' >/dev/null 2>&1 &&
+   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+  as_basename=basename
+else
+  as_basename=false
+fi
+
+if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
+  as_dirname=dirname
+else
+  as_dirname=false
+fi
+
+as_me=`$as_basename -- "$0" ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+ECHO_C= ECHO_N= ECHO_T=
+case `echo -n x` in #(((((
+-n*)
+  case `echo 'xy\c'` in
+  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
+  xy)  ECHO_C='\c';;
+  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
+       ECHO_T='	';;
+  esac;;
+*)
+  ECHO_N='-n';;
+esac
+
+rm -f conf$$ conf$$.exe conf$$.file
+if test -d conf$$.dir; then
+  rm -f conf$$.dir/conf$$.file
+else
+  rm -f conf$$.dir
+  mkdir conf$$.dir 2>/dev/null
+fi
+if (echo >conf$$.file) 2>/dev/null; then
+  if ln -s conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s='ln -s'
+    # ... but there are two gotchas:
+    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
+    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
+    # In both cases, we have to default to `cp -p'.
+    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+      as_ln_s='cp -p'
+  elif ln conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s=ln
+  else
+    as_ln_s='cp -p'
+  fi
+else
+  as_ln_s='cp -p'
+fi
+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
+rmdir conf$$.dir 2>/dev/null
+
+
+# as_fn_mkdir_p
+# -------------
+# Create "$as_dir" as a directory, including parents if necessary.
+as_fn_mkdir_p ()
+{
+
+  case $as_dir in #(
+  -*) as_dir=./$as_dir;;
+  esac
+  test -d "$as_dir" || eval $as_mkdir_p || {
+    as_dirs=
+    while :; do
+      case $as_dir in #(
+      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
+      *) as_qdir=$as_dir;;
+      esac
+      as_dirs="'$as_qdir' $as_dirs"
+      as_dir=`$as_dirname -- "$as_dir" ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_dir" : 'X\(//\)[^/]' \| \
+	 X"$as_dir" : 'X\(//\)$' \| \
+	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$as_dir" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+      test -d "$as_dir" && break
+    done
+    test -z "$as_dirs" || eval "mkdir $as_dirs"
+  } || test -d "$as_dir" || as_fn_error "cannot create directory $as_dir"
+
+
+} # as_fn_mkdir_p
+if mkdir -p . 2>/dev/null; then
+  as_mkdir_p='mkdir -p "$as_dir"'
+else
+  test -d ./-p && rmdir ./-p
+  as_mkdir_p=false
+fi
+
+if test -x / >/dev/null 2>&1; then
+  as_test_x='test -x'
+else
+  if ls -dL / >/dev/null 2>&1; then
+    as_ls_L_option=L
+  else
+    as_ls_L_option=
+  fi
+  as_test_x='
+    eval sh -c '\''
+      if test -d "$1"; then
+	test -d "$1/.";
+      else
+	case $1 in #(
+	-*)set "./$1";;
+	esac;
+	case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
+	???[sx]*):;;*)false;;esac;fi
+    '\'' sh
+  '
+fi
+as_executable_p=$as_test_x
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+
+
+exec 6>&1
+## ----------------------------------- ##
+## Main body of $CONFIG_STATUS script. ##
+## ----------------------------------- ##
+_ASEOF
+test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# Save the log message, to keep $0 and so on meaningful, and to
+# report actual input values of CONFIG_FILES etc. instead of their
+# values after options handling.
+ac_log="
+This file was extended by OpenACC Runtime Library $as_me 1.0, which was
+generated by GNU Autoconf 2.64.  Invocation command line was
+
+  CONFIG_FILES    = $CONFIG_FILES
+  CONFIG_HEADERS  = $CONFIG_HEADERS
+  CONFIG_LINKS    = $CONFIG_LINKS
+  CONFIG_COMMANDS = $CONFIG_COMMANDS
+  $ $0 $@
+
+on `(hostname || uname -n) 2>/dev/null | sed 1q`
+"
+
+_ACEOF
+
+case $ac_config_files in *"
+"*) set x $ac_config_files; shift; ac_config_files=$*;;
+esac
+
+case $ac_config_headers in *"
+"*) set x $ac_config_headers; shift; ac_config_headers=$*;;
+esac
+
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+# Files that config.status was made for.
+config_files="$ac_config_files"
+config_headers="$ac_config_headers"
+config_commands="$ac_config_commands"
+
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+ac_cs_usage="\
+\`$as_me' instantiates files and other configuration actions
+from templates according to the current configuration.  Unless the files
+and actions are specified as TAGs, all are instantiated by default.
+
+Usage: $0 [OPTION]... [TAG]...
+
+  -h, --help       print this help, then exit
+  -V, --version    print version number and configuration settings, then exit
+  -q, --quiet, --silent
+                   do not print progress messages
+  -d, --debug      don't remove temporary files
+      --recheck    update $as_me by reconfiguring in the same conditions
+      --file=FILE[:TEMPLATE]
+                   instantiate the configuration file FILE
+      --header=FILE[:TEMPLATE]
+                   instantiate the configuration header FILE
+
+Configuration files:
+$config_files
+
+Configuration headers:
+$config_headers
+
+Configuration commands:
+$config_commands
+
+Report bugs to <dark_beer@rambler.ru>."
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ac_cs_version="\\
+OpenACC Runtime Library config.status 1.0
+configured by $0, generated by GNU Autoconf 2.64,
+  with options \\"`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"
+
+Copyright (C) 2009 Free Software Foundation, Inc.
+This config.status script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it."
+
+ac_pwd='$ac_pwd'
+srcdir='$srcdir'
+INSTALL='$INSTALL'
+MKDIR_P='$MKDIR_P'
+AWK='$AWK'
+test -n "\$AWK" || AWK=awk
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# The default lists apply if the user does not specify any file.
+ac_need_defaults=:
+while test $# != 0
+do
+  case $1 in
+  --*=*)
+    ac_option=`expr "X$1" : 'X\([^=]*\)='`
+    ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
+    ac_shift=:
+    ;;
+  *)
+    ac_option=$1
+    ac_optarg=$2
+    ac_shift=shift
+    ;;
+  esac
+
+  case $ac_option in
+  # Handling of the options.
+  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
+    ac_cs_recheck=: ;;
+  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
+    $as_echo "$ac_cs_version"; exit ;;
+  --debug | --debu | --deb | --de | --d | -d )
+    debug=: ;;
+  --file | --fil | --fi | --f )
+    $ac_shift
+    case $ac_optarg in
+    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    esac
+    as_fn_append CONFIG_FILES " '$ac_optarg'"
+    ac_need_defaults=false;;
+  --header | --heade | --head | --hea )
+    $ac_shift
+    case $ac_optarg in
+    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    esac
+    as_fn_append CONFIG_HEADERS " '$ac_optarg'"
+    ac_need_defaults=false;;
+  --he | --h)
+    # Conflict between --help and --header
+    as_fn_error "ambiguous option: \`$1'
+Try \`$0 --help' for more information.";;
+  --help | --hel | -h )
+    $as_echo "$ac_cs_usage"; exit ;;
+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+  | -silent | --silent | --silen | --sile | --sil | --si | --s)
+    ac_cs_silent=: ;;
+
+  # This is an error.
+  -*) as_fn_error "unrecognized option: \`$1'
+Try \`$0 --help' for more information." ;;
+
+  *) as_fn_append ac_config_targets " $1"
+     ac_need_defaults=false ;;
+
+  esac
+  shift
+done
+
+ac_configure_extra_args=
+
+if $ac_cs_silent; then
+  exec 6>/dev/null
+  ac_configure_extra_args="$ac_configure_extra_args --silent"
+fi
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+if \$ac_cs_recheck; then
+  set X '$SHELL' '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
+  shift
+  \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
+  CONFIG_SHELL='$SHELL'
+  export CONFIG_SHELL
+  exec "\$@"
+fi
+
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+exec 5>>config.log
+{
+  echo
+  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
+## Running $as_me. ##
+_ASBOX
+  $as_echo "$ac_log"
+} >&5
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+#
+# INIT-COMMANDS
+#
+
+srcdir="$srcdir"
+host="$host"
+target="$target"
+with_multisubdir="$with_multisubdir"
+with_multisrctop="$with_multisrctop"
+with_target_subdir="$with_target_subdir"
+ac_configure_args="${multilib_arg} ${ac_configure_args}"
+multi_basedir="$multi_basedir"
+CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
+CC="$CC"
+CXX="$CXX"
+GFORTRAN="$GFORTRAN"
+GCJ="$GCJ"
+AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
+
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+sed_quote_subst='$sed_quote_subst'
+double_quote_subst='$double_quote_subst'
+delay_variable_subst='$delay_variable_subst'
+macro_version='`$ECHO "$macro_version" | $SED "$delay_single_quote_subst"`'
+macro_revision='`$ECHO "$macro_revision" | $SED "$delay_single_quote_subst"`'
+enable_shared='`$ECHO "$enable_shared" | $SED "$delay_single_quote_subst"`'
+enable_static='`$ECHO "$enable_static" | $SED "$delay_single_quote_subst"`'
+pic_mode='`$ECHO "$pic_mode" | $SED "$delay_single_quote_subst"`'
+enable_fast_install='`$ECHO "$enable_fast_install" | $SED "$delay_single_quote_subst"`'
+SHELL='`$ECHO "$SHELL" | $SED "$delay_single_quote_subst"`'
+ECHO='`$ECHO "$ECHO" | $SED "$delay_single_quote_subst"`'
+host_alias='`$ECHO "$host_alias" | $SED "$delay_single_quote_subst"`'
+host='`$ECHO "$host" | $SED "$delay_single_quote_subst"`'
+host_os='`$ECHO "$host_os" | $SED "$delay_single_quote_subst"`'
+build_alias='`$ECHO "$build_alias" | $SED "$delay_single_quote_subst"`'
+build='`$ECHO "$build" | $SED "$delay_single_quote_subst"`'
+build_os='`$ECHO "$build_os" | $SED "$delay_single_quote_subst"`'
+SED='`$ECHO "$SED" | $SED "$delay_single_quote_subst"`'
+Xsed='`$ECHO "$Xsed" | $SED "$delay_single_quote_subst"`'
+GREP='`$ECHO "$GREP" | $SED "$delay_single_quote_subst"`'
+EGREP='`$ECHO "$EGREP" | $SED "$delay_single_quote_subst"`'
+FGREP='`$ECHO "$FGREP" | $SED "$delay_single_quote_subst"`'
+LD='`$ECHO "$LD" | $SED "$delay_single_quote_subst"`'
+NM='`$ECHO "$NM" | $SED "$delay_single_quote_subst"`'
+LN_S='`$ECHO "$LN_S" | $SED "$delay_single_quote_subst"`'
+max_cmd_len='`$ECHO "$max_cmd_len" | $SED "$delay_single_quote_subst"`'
+ac_objext='`$ECHO "$ac_objext" | $SED "$delay_single_quote_subst"`'
+exeext='`$ECHO "$exeext" | $SED "$delay_single_quote_subst"`'
+lt_unset='`$ECHO "$lt_unset" | $SED "$delay_single_quote_subst"`'
+lt_SP2NL='`$ECHO "$lt_SP2NL" | $SED "$delay_single_quote_subst"`'
+lt_NL2SP='`$ECHO "$lt_NL2SP" | $SED "$delay_single_quote_subst"`'
+reload_flag='`$ECHO "$reload_flag" | $SED "$delay_single_quote_subst"`'
+reload_cmds='`$ECHO "$reload_cmds" | $SED "$delay_single_quote_subst"`'
+OBJDUMP='`$ECHO "$OBJDUMP" | $SED "$delay_single_quote_subst"`'
+deplibs_check_method='`$ECHO "$deplibs_check_method" | $SED "$delay_single_quote_subst"`'
+file_magic_cmd='`$ECHO "$file_magic_cmd" | $SED "$delay_single_quote_subst"`'
+AR='`$ECHO "$AR" | $SED "$delay_single_quote_subst"`'
+AR_FLAGS='`$ECHO "$AR_FLAGS" | $SED "$delay_single_quote_subst"`'
+STRIP='`$ECHO "$STRIP" | $SED "$delay_single_quote_subst"`'
+RANLIB='`$ECHO "$RANLIB" | $SED "$delay_single_quote_subst"`'
+old_postinstall_cmds='`$ECHO "$old_postinstall_cmds" | $SED "$delay_single_quote_subst"`'
+old_postuninstall_cmds='`$ECHO "$old_postuninstall_cmds" | $SED "$delay_single_quote_subst"`'
+old_archive_cmds='`$ECHO "$old_archive_cmds" | $SED "$delay_single_quote_subst"`'
+lock_old_archive_extraction='`$ECHO "$lock_old_archive_extraction" | $SED "$delay_single_quote_subst"`'
+CC='`$ECHO "$CC" | $SED "$delay_single_quote_subst"`'
+CFLAGS='`$ECHO "$CFLAGS" | $SED "$delay_single_quote_subst"`'
+compiler='`$ECHO "$compiler" | $SED "$delay_single_quote_subst"`'
+GCC='`$ECHO "$GCC" | $SED "$delay_single_quote_subst"`'
+lt_cv_sys_global_symbol_pipe='`$ECHO "$lt_cv_sys_global_symbol_pipe" | $SED "$delay_single_quote_subst"`'
+lt_cv_sys_global_symbol_to_cdecl='`$ECHO "$lt_cv_sys_global_symbol_to_cdecl" | $SED "$delay_single_quote_subst"`'
+lt_cv_sys_global_symbol_to_c_name_address='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address" | $SED "$delay_single_quote_subst"`'
+lt_cv_sys_global_symbol_to_c_name_address_lib_prefix='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address_lib_prefix" | $SED "$delay_single_quote_subst"`'
+objdir='`$ECHO "$objdir" | $SED "$delay_single_quote_subst"`'
+MAGIC_CMD='`$ECHO "$MAGIC_CMD" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_no_builtin_flag='`$ECHO "$lt_prog_compiler_no_builtin_flag" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_wl='`$ECHO "$lt_prog_compiler_wl" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_pic='`$ECHO "$lt_prog_compiler_pic" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_static='`$ECHO "$lt_prog_compiler_static" | $SED "$delay_single_quote_subst"`'
+lt_cv_prog_compiler_c_o='`$ECHO "$lt_cv_prog_compiler_c_o" | $SED "$delay_single_quote_subst"`'
+need_locks='`$ECHO "$need_locks" | $SED "$delay_single_quote_subst"`'
+DSYMUTIL='`$ECHO "$DSYMUTIL" | $SED "$delay_single_quote_subst"`'
+NMEDIT='`$ECHO "$NMEDIT" | $SED "$delay_single_quote_subst"`'
+LIPO='`$ECHO "$LIPO" | $SED "$delay_single_quote_subst"`'
+OTOOL='`$ECHO "$OTOOL" | $SED "$delay_single_quote_subst"`'
+OTOOL64='`$ECHO "$OTOOL64" | $SED "$delay_single_quote_subst"`'
+libext='`$ECHO "$libext" | $SED "$delay_single_quote_subst"`'
+shrext_cmds='`$ECHO "$shrext_cmds" | $SED "$delay_single_quote_subst"`'
+extract_expsyms_cmds='`$ECHO "$extract_expsyms_cmds" | $SED "$delay_single_quote_subst"`'
+archive_cmds_need_lc='`$ECHO "$archive_cmds_need_lc" | $SED "$delay_single_quote_subst"`'
+enable_shared_with_static_runtimes='`$ECHO "$enable_shared_with_static_runtimes" | $SED "$delay_single_quote_subst"`'
+export_dynamic_flag_spec='`$ECHO "$export_dynamic_flag_spec" | $SED "$delay_single_quote_subst"`'
+whole_archive_flag_spec='`$ECHO "$whole_archive_flag_spec" | $SED "$delay_single_quote_subst"`'
+compiler_needs_object='`$ECHO "$compiler_needs_object" | $SED "$delay_single_quote_subst"`'
+old_archive_from_new_cmds='`$ECHO "$old_archive_from_new_cmds" | $SED "$delay_single_quote_subst"`'
+old_archive_from_expsyms_cmds='`$ECHO "$old_archive_from_expsyms_cmds" | $SED "$delay_single_quote_subst"`'
+archive_cmds='`$ECHO "$archive_cmds" | $SED "$delay_single_quote_subst"`'
+archive_expsym_cmds='`$ECHO "$archive_expsym_cmds" | $SED "$delay_single_quote_subst"`'
+module_cmds='`$ECHO "$module_cmds" | $SED "$delay_single_quote_subst"`'
+module_expsym_cmds='`$ECHO "$module_expsym_cmds" | $SED "$delay_single_quote_subst"`'
+with_gnu_ld='`$ECHO "$with_gnu_ld" | $SED "$delay_single_quote_subst"`'
+allow_undefined_flag='`$ECHO "$allow_undefined_flag" | $SED "$delay_single_quote_subst"`'
+no_undefined_flag='`$ECHO "$no_undefined_flag" | $SED "$delay_single_quote_subst"`'
+hardcode_libdir_flag_spec='`$ECHO "$hardcode_libdir_flag_spec" | $SED "$delay_single_quote_subst"`'
+hardcode_libdir_flag_spec_ld='`$ECHO "$hardcode_libdir_flag_spec_ld" | $SED "$delay_single_quote_subst"`'
+hardcode_libdir_separator='`$ECHO "$hardcode_libdir_separator" | $SED "$delay_single_quote_subst"`'
+hardcode_direct='`$ECHO "$hardcode_direct" | $SED "$delay_single_quote_subst"`'
+hardcode_direct_absolute='`$ECHO "$hardcode_direct_absolute" | $SED "$delay_single_quote_subst"`'
+hardcode_minus_L='`$ECHO "$hardcode_minus_L" | $SED "$delay_single_quote_subst"`'
+hardcode_shlibpath_var='`$ECHO "$hardcode_shlibpath_var" | $SED "$delay_single_quote_subst"`'
+hardcode_automatic='`$ECHO "$hardcode_automatic" | $SED "$delay_single_quote_subst"`'
+inherit_rpath='`$ECHO "$inherit_rpath" | $SED "$delay_single_quote_subst"`'
+link_all_deplibs='`$ECHO "$link_all_deplibs" | $SED "$delay_single_quote_subst"`'
+fix_srcfile_path='`$ECHO "$fix_srcfile_path" | $SED "$delay_single_quote_subst"`'
+always_export_symbols='`$ECHO "$always_export_symbols" | $SED "$delay_single_quote_subst"`'
+export_symbols_cmds='`$ECHO "$export_symbols_cmds" | $SED "$delay_single_quote_subst"`'
+exclude_expsyms='`$ECHO "$exclude_expsyms" | $SED "$delay_single_quote_subst"`'
+include_expsyms='`$ECHO "$include_expsyms" | $SED "$delay_single_quote_subst"`'
+prelink_cmds='`$ECHO "$prelink_cmds" | $SED "$delay_single_quote_subst"`'
+file_list_spec='`$ECHO "$file_list_spec" | $SED "$delay_single_quote_subst"`'
+variables_saved_for_relink='`$ECHO "$variables_saved_for_relink" | $SED "$delay_single_quote_subst"`'
+need_lib_prefix='`$ECHO "$need_lib_prefix" | $SED "$delay_single_quote_subst"`'
+need_version='`$ECHO "$need_version" | $SED "$delay_single_quote_subst"`'
+version_type='`$ECHO "$version_type" | $SED "$delay_single_quote_subst"`'
+runpath_var='`$ECHO "$runpath_var" | $SED "$delay_single_quote_subst"`'
+shlibpath_var='`$ECHO "$shlibpath_var" | $SED "$delay_single_quote_subst"`'
+shlibpath_overrides_runpath='`$ECHO "$shlibpath_overrides_runpath" | $SED "$delay_single_quote_subst"`'
+libname_spec='`$ECHO "$libname_spec" | $SED "$delay_single_quote_subst"`'
+library_names_spec='`$ECHO "$library_names_spec" | $SED "$delay_single_quote_subst"`'
+soname_spec='`$ECHO "$soname_spec" | $SED "$delay_single_quote_subst"`'
+install_override_mode='`$ECHO "$install_override_mode" | $SED "$delay_single_quote_subst"`'
+postinstall_cmds='`$ECHO "$postinstall_cmds" | $SED "$delay_single_quote_subst"`'
+postuninstall_cmds='`$ECHO "$postuninstall_cmds" | $SED "$delay_single_quote_subst"`'
+finish_cmds='`$ECHO "$finish_cmds" | $SED "$delay_single_quote_subst"`'
+finish_eval='`$ECHO "$finish_eval" | $SED "$delay_single_quote_subst"`'
+hardcode_into_libs='`$ECHO "$hardcode_into_libs" | $SED "$delay_single_quote_subst"`'
+sys_lib_search_path_spec='`$ECHO "$sys_lib_search_path_spec" | $SED "$delay_single_quote_subst"`'
+sys_lib_dlsearch_path_spec='`$ECHO "$sys_lib_dlsearch_path_spec" | $SED "$delay_single_quote_subst"`'
+hardcode_action='`$ECHO "$hardcode_action" | $SED "$delay_single_quote_subst"`'
+enable_dlopen='`$ECHO "$enable_dlopen" | $SED "$delay_single_quote_subst"`'
+enable_dlopen_self='`$ECHO "$enable_dlopen_self" | $SED "$delay_single_quote_subst"`'
+enable_dlopen_self_static='`$ECHO "$enable_dlopen_self_static" | $SED "$delay_single_quote_subst"`'
+old_striplib='`$ECHO "$old_striplib" | $SED "$delay_single_quote_subst"`'
+striplib='`$ECHO "$striplib" | $SED "$delay_single_quote_subst"`'
+
+LTCC='$LTCC'
+LTCFLAGS='$LTCFLAGS'
+compiler='$compiler_DEFAULT'
+
+# A function that is used when there is no print builtin or printf.
+func_fallback_echo ()
+{
+  eval 'cat <<_LTECHO_EOF
+\$1
+_LTECHO_EOF'
+}
+
+# Quote evaled strings.
+for var in SHELL \
+ECHO \
+SED \
+GREP \
+EGREP \
+FGREP \
+LD \
+NM \
+LN_S \
+lt_SP2NL \
+lt_NL2SP \
+reload_flag \
+OBJDUMP \
+deplibs_check_method \
+file_magic_cmd \
+AR \
+AR_FLAGS \
+STRIP \
+RANLIB \
+CC \
+CFLAGS \
+compiler \
+lt_cv_sys_global_symbol_pipe \
+lt_cv_sys_global_symbol_to_cdecl \
+lt_cv_sys_global_symbol_to_c_name_address \
+lt_cv_sys_global_symbol_to_c_name_address_lib_prefix \
+lt_prog_compiler_no_builtin_flag \
+lt_prog_compiler_wl \
+lt_prog_compiler_pic \
+lt_prog_compiler_static \
+lt_cv_prog_compiler_c_o \
+need_locks \
+DSYMUTIL \
+NMEDIT \
+LIPO \
+OTOOL \
+OTOOL64 \
+shrext_cmds \
+export_dynamic_flag_spec \
+whole_archive_flag_spec \
+compiler_needs_object \
+with_gnu_ld \
+allow_undefined_flag \
+no_undefined_flag \
+hardcode_libdir_flag_spec \
+hardcode_libdir_flag_spec_ld \
+hardcode_libdir_separator \
+fix_srcfile_path \
+exclude_expsyms \
+include_expsyms \
+file_list_spec \
+variables_saved_for_relink \
+libname_spec \
+library_names_spec \
+soname_spec \
+install_override_mode \
+finish_eval \
+old_striplib \
+striplib; do
+    case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
+    *[\\\\\\\`\\"\\\$]*)
+      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\""
+      ;;
+    *)
+      eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
+      ;;
+    esac
+done
+
+# Double-quote double-evaled strings.
+for var in reload_cmds \
+old_postinstall_cmds \
+old_postuninstall_cmds \
+old_archive_cmds \
+extract_expsyms_cmds \
+old_archive_from_new_cmds \
+old_archive_from_expsyms_cmds \
+archive_cmds \
+archive_expsym_cmds \
+module_cmds \
+module_expsym_cmds \
+export_symbols_cmds \
+prelink_cmds \
+postinstall_cmds \
+postuninstall_cmds \
+finish_cmds \
+sys_lib_search_path_spec \
+sys_lib_dlsearch_path_spec; do
+    case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
+    *[\\\\\\\`\\"\\\$]*)
+      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\""
+      ;;
+    *)
+      eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
+      ;;
+    esac
+done
+
+ac_aux_dir='$ac_aux_dir'
+xsi_shell='$xsi_shell'
+lt_shell_append='$lt_shell_append'
+
+# See if we are running on zsh, and set the options which allow our
+# commands through without removal of \ escapes INIT.
+if test -n "\${ZSH_VERSION+set}" ; then
+   setopt NO_GLOB_SUBST
+fi
+
+
+    PACKAGE='$PACKAGE'
+    VERSION='$VERSION'
+    TIMESTAMP='$TIMESTAMP'
+    RM='$RM'
+    ofile='$ofile'
+
+
+
+
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+
+# Handling of arguments.
+for ac_config_target in $ac_config_targets
+do
+  case $ac_config_target in
+    "default-1") CONFIG_COMMANDS="$CONFIG_COMMANDS default-1" ;;
+    "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
+    "libtool") CONFIG_COMMANDS="$CONFIG_COMMANDS libtool" ;;
+    "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
+    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
+    "liboacc.spec") CONFIG_FILES="$CONFIG_FILES liboacc.spec" ;;
+
+  *) as_fn_error "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
+  esac
+done
+
+
+# If the user did not use the arguments to specify the items to instantiate,
+# then the envvar interface is used.  Set only those that are not.
+# We use the long form for the default assignment because of an extremely
+# bizarre bug on SunOS 4.1.3.
+if $ac_need_defaults; then
+  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
+  test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
+  test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands
+fi
+
+# Have a temporary directory for convenience.  Make it in the build tree
+# simply because there is no reason against having it here, and in addition,
+# creating and moving files from /tmp can sometimes cause problems.
+# Hook for its removal unless debugging.
+# Note that there is a small window in which the directory will not be cleaned:
+# after its creation but before its name has been assigned to `$tmp'.
+$debug ||
+{
+  tmp=
+  trap 'exit_status=$?
+  { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status
+' 0
+  trap 'as_fn_exit 1' 1 2 13 15
+}
+# Create a (secure) tmp directory for tmp files.
+
+{
+  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
+  test -n "$tmp" && test -d "$tmp"
+}  ||
+{
+  tmp=./conf$$-$RANDOM
+  (umask 077 && mkdir "$tmp")
+} || as_fn_error "cannot create a temporary directory in ." "$LINENO" 5
+
+# Set up the scripts for CONFIG_FILES section.
+# No need to generate them if there are no CONFIG_FILES.
+# This happens for instance with `./config.status config.h'.
+if test -n "$CONFIG_FILES"; then
+
+
+ac_cr=`echo X | tr X '\015'`
+# On cygwin, bash can eat \r inside `` if the user requested igncr.
+# But we know of no other shell where ac_cr would be empty at this
+# point, so we can use a bashism as a fallback.
+if test "x$ac_cr" = x; then
+  eval ac_cr=\$\'\\r\'
+fi
+ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
+if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
+  ac_cs_awk_cr='\r'
+else
+  ac_cs_awk_cr=$ac_cr
+fi
+
+echo 'BEGIN {' >"$tmp/subs1.awk" &&
+_ACEOF
+
+
+{
+  echo "cat >conf$$subs.awk <<_ACEOF" &&
+  echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
+  echo "_ACEOF"
+} >conf$$subs.sh ||
+  as_fn_error "could not make $CONFIG_STATUS" "$LINENO" 5
+ac_delim_num=`echo "$ac_subst_vars" | grep -c '$'`
+ac_delim='%!_!# '
+for ac_last_try in false false false false false :; do
+  . ./conf$$subs.sh ||
+    as_fn_error "could not make $CONFIG_STATUS" "$LINENO" 5
+
+  ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
+  if test $ac_delim_n = $ac_delim_num; then
+    break
+  elif $ac_last_try; then
+    as_fn_error "could not make $CONFIG_STATUS" "$LINENO" 5
+  else
+    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
+  fi
+done
+rm -f conf$$subs.sh
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+cat >>"\$tmp/subs1.awk" <<\\_ACAWK &&
+_ACEOF
+sed -n '
+h
+s/^/S["/; s/!.*/"]=/
+p
+g
+s/^[^!]*!//
+:repl
+t repl
+s/'"$ac_delim"'$//
+t delim
+:nl
+h
+s/\(.\{148\}\).*/\1/
+t more1
+s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
+p
+n
+b repl
+:more1
+s/["\\]/\\&/g; s/^/"/; s/$/"\\/
+p
+g
+s/.\{148\}//
+t nl
+:delim
+h
+s/\(.\{148\}\).*/\1/
+t more2
+s/["\\]/\\&/g; s/^/"/; s/$/"/
+p
+b
+:more2
+s/["\\]/\\&/g; s/^/"/; s/$/"\\/
+p
+g
+s/.\{148\}//
+t delim
+' <conf$$subs.awk | sed '
+/^[^""]/{
+  N
+  s/\n//
+}
+' >>$CONFIG_STATUS || ac_write_fail=1
+rm -f conf$$subs.awk
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+_ACAWK
+cat >>"\$tmp/subs1.awk" <<_ACAWK &&
+  for (key in S) S_is_set[key] = 1
+  FS = ""
+
+}
+{
+  line = $ 0
+  nfields = split(line, field, "@")
+  substed = 0
+  len = length(field[1])
+  for (i = 2; i < nfields; i++) {
+    key = field[i]
+    keylen = length(key)
+    if (S_is_set[key]) {
+      value = S[key]
+      line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3)
+      len += length(value) + length(field[++i])
+      substed = 1
+    } else
+      len += 1 + keylen
+  }
+
+  print line
+}
+
+_ACAWK
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
+  sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
+else
+  cat
+fi < "$tmp/subs1.awk" > "$tmp/subs.awk" \
+  || as_fn_error "could not setup config files machinery" "$LINENO" 5
+_ACEOF
+
+# VPATH may cause trouble with some makes, so we remove $(srcdir),
+# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
+# trailing colons and then remove the whole line if VPATH becomes empty
+# (actually we leave an empty line to preserve line numbers).
+if test "x$srcdir" = x.; then
+  ac_vpsub='/^[	 ]*VPATH[	 ]*=/{
+s/:*\$(srcdir):*/:/
+s/:*\${srcdir}:*/:/
+s/:*@srcdir@:*/:/
+s/^\([^=]*=[	 ]*\):*/\1/
+s/:*$//
+s/^[^=]*=[	 ]*$//
+}'
+fi
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+fi # test -n "$CONFIG_FILES"
+
+# Set up the scripts for CONFIG_HEADERS section.
+# No need to generate them if there are no CONFIG_HEADERS.
+# This happens for instance with `./config.status Makefile'.
+if test -n "$CONFIG_HEADERS"; then
+cat >"$tmp/defines.awk" <<\_ACAWK ||
+BEGIN {
+_ACEOF
+
+# Transform confdefs.h into an awk script `defines.awk', embedded as
+# here-document in config.status, that substitutes the proper values into
+# config.h.in to produce config.h.
+
+# Create a delimiter string that does not exist in confdefs.h, to ease
+# handling of long lines.
+ac_delim='%!_!# '
+for ac_last_try in false false :; do
+  ac_t=`sed -n "/$ac_delim/p" confdefs.h`
+  if test -z "$ac_t"; then
+    break
+  elif $ac_last_try; then
+    as_fn_error "could not make $CONFIG_HEADERS" "$LINENO" 5
+  else
+    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
+  fi
+done
+
+# For the awk script, D is an array of macro values keyed by name,
+# likewise P contains macro parameters if any.  Preserve backslash
+# newline sequences.
+
+ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]*
+sed -n '
+s/.\{148\}/&'"$ac_delim"'/g
+t rset
+:rset
+s/^[	 ]*#[	 ]*define[	 ][	 ]*/ /
+t def
+d
+:def
+s/\\$//
+t bsnl
+s/["\\]/\\&/g
+s/^ \('"$ac_word_re"'\)\(([^()]*)\)[	 ]*\(.*\)/P["\1"]="\2"\
+D["\1"]=" \3"/p
+s/^ \('"$ac_word_re"'\)[	 ]*\(.*\)/D["\1"]=" \2"/p
+d
+:bsnl
+s/["\\]/\\&/g
+s/^ \('"$ac_word_re"'\)\(([^()]*)\)[	 ]*\(.*\)/P["\1"]="\2"\
+D["\1"]=" \3\\\\\\n"\\/p
+t cont
+s/^ \('"$ac_word_re"'\)[	 ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p
+t cont
+d
+:cont
+n
+s/.\{148\}/&'"$ac_delim"'/g
+t clear
+:clear
+s/\\$//
+t bsnlc
+s/["\\]/\\&/g; s/^/"/; s/$/"/p
+d
+:bsnlc
+s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p
+b cont
+' <confdefs.h | sed '
+s/'"$ac_delim"'/"\\\
+"/g' >>$CONFIG_STATUS || ac_write_fail=1
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+  for (key in D) D_is_set[key] = 1
+  FS = ""
+}
+/^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ {
+  line = \$ 0
+  split(line, arg, " ")
+  if (arg[1] == "#") {
+    defundef = arg[2]
+    mac1 = arg[3]
+  } else {
+    defundef = substr(arg[1], 2)
+    mac1 = arg[2]
+  }
+  split(mac1, mac2, "(") #)
+  macro = mac2[1]
+  prefix = substr(line, 1, index(line, defundef) - 1)
+  if (D_is_set[macro]) {
+    # Preserve the white space surrounding the "#".
+    print prefix "define", macro P[macro] D[macro]
+    next
+  } else {
+    # Replace #undef with comments.  This is necessary, for example,
+    # in the case of _POSIX_SOURCE, which is predefined and required
+    # on some systems where configure will not decide to define it.
+    if (defundef == "undef") {
+      print "/*", prefix defundef, macro, "*/"
+      next
+    }
+  }
+}
+{ print }
+_ACAWK
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+  as_fn_error "could not setup config headers machinery" "$LINENO" 5
+fi # test -n "$CONFIG_HEADERS"
+
+
+eval set X "  :F $CONFIG_FILES  :H $CONFIG_HEADERS    :C $CONFIG_COMMANDS"
+shift
+for ac_tag
+do
+  case $ac_tag in
+  :[FHLC]) ac_mode=$ac_tag; continue;;
+  esac
+  case $ac_mode$ac_tag in
+  :[FHL]*:*);;
+  :L* | :C*:*) as_fn_error "invalid tag \`$ac_tag'" "$LINENO" 5;;
+  :[FH]-) ac_tag=-:-;;
+  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
+  esac
+  ac_save_IFS=$IFS
+  IFS=:
+  set x $ac_tag
+  IFS=$ac_save_IFS
+  shift
+  ac_file=$1
+  shift
+
+  case $ac_mode in
+  :L) ac_source=$1;;
+  :[FH])
+    ac_file_inputs=
+    for ac_f
+    do
+      case $ac_f in
+      -) ac_f="$tmp/stdin";;
+      *) # Look for the file first in the build tree, then in the source tree
+	 # (if the path is not absolute).  The absolute path cannot be DOS-style,
+	 # because $ac_f cannot contain `:'.
+	 test -f "$ac_f" ||
+	   case $ac_f in
+	   [\\/$]*) false;;
+	   *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
+	   esac ||
+	   as_fn_error "cannot find input file: \`$ac_f'" "$LINENO" 5;;
+      esac
+      case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
+      as_fn_append ac_file_inputs " '$ac_f'"
+    done
+
+    # Let's still pretend it is `configure' which instantiates (i.e., don't
+    # use $as_me), people would be surprised to read:
+    #    /* config.h.  Generated by config.status.  */
+    configure_input='Generated from '`
+	  $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
+	`' by configure.'
+    if test x"$ac_file" != x-; then
+      configure_input="$ac_file.  $configure_input"
+      { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
+$as_echo "$as_me: creating $ac_file" >&6;}
+    fi
+    # Neutralize special characters interpreted by sed in replacement strings.
+    case $configure_input in #(
+    *\&* | *\|* | *\\* )
+       ac_sed_conf_input=`$as_echo "$configure_input" |
+       sed 's/[\\\\&|]/\\\\&/g'`;; #(
+    *) ac_sed_conf_input=$configure_input;;
+    esac
+
+    case $ac_tag in
+    *:-:* | *:-) cat >"$tmp/stdin" \
+      || as_fn_error "could not create $ac_file" "$LINENO" 5 ;;
+    esac
+    ;;
+  esac
+
+  ac_dir=`$as_dirname -- "$ac_file" ||
+$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$ac_file" : 'X\(//\)[^/]' \| \
+	 X"$ac_file" : 'X\(//\)$' \| \
+	 X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$ac_file" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+  as_dir="$ac_dir"; as_fn_mkdir_p
+  ac_builddir=.
+
+case "$ac_dir" in
+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+*)
+  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
+  # A ".." for each directory in $ac_dir_suffix.
+  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
+  case $ac_top_builddir_sub in
+  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+  esac ;;
+esac
+ac_abs_top_builddir=$ac_pwd
+ac_abs_builddir=$ac_pwd$ac_dir_suffix
+# for backward compatibility:
+ac_top_builddir=$ac_top_build_prefix
+
+case $srcdir in
+  .)  # We are building in place.
+    ac_srcdir=.
+    ac_top_srcdir=$ac_top_builddir_sub
+    ac_abs_top_srcdir=$ac_pwd ;;
+  [\\/]* | ?:[\\/]* )  # Absolute name.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir
+    ac_abs_top_srcdir=$srcdir ;;
+  *) # Relative name.
+    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_build_prefix$srcdir
+    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
+esac
+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+
+
+  case $ac_mode in
+  :F)
+  #
+  # CONFIG_FILE
+  #
+
+  case $INSTALL in
+  [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
+  *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;;
+  esac
+  ac_MKDIR_P=$MKDIR_P
+  case $MKDIR_P in
+  [\\/$]* | ?:[\\/]* ) ;;
+  */*) ac_MKDIR_P=$ac_top_build_prefix$MKDIR_P ;;
+  esac
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# If the template does not know about datarootdir, expand it.
+# FIXME: This hack should be removed a few years after 2.60.
+ac_datarootdir_hack=; ac_datarootdir_seen=
+ac_sed_dataroot='
+/datarootdir/ {
+  p
+  q
+}
+/@datadir@/p
+/@docdir@/p
+/@infodir@/p
+/@localedir@/p
+/@mandir@/p'
+case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
+*datarootdir*) ac_datarootdir_seen=yes;;
+*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
+$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+  ac_datarootdir_hack='
+  s&@datadir@&$datadir&g
+  s&@docdir@&$docdir&g
+  s&@infodir@&$infodir&g
+  s&@localedir@&$localedir&g
+  s&@mandir@&$mandir&g
+  s&\\\${datarootdir}&$datarootdir&g' ;;
+esac
+_ACEOF
+
+# Neutralize VPATH when `$srcdir' = `.'.
+# Shell code in configure.ac might set extrasub.
+# FIXME: do we really want to maintain this feature?
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ac_sed_extra="$ac_vpsub
+$extrasub
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+:t
+/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
+s|@configure_input@|$ac_sed_conf_input|;t t
+s&@top_builddir@&$ac_top_builddir_sub&;t t
+s&@top_build_prefix@&$ac_top_build_prefix&;t t
+s&@srcdir@&$ac_srcdir&;t t
+s&@abs_srcdir@&$ac_abs_srcdir&;t t
+s&@top_srcdir@&$ac_top_srcdir&;t t
+s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
+s&@builddir@&$ac_builddir&;t t
+s&@abs_builddir@&$ac_abs_builddir&;t t
+s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
+s&@INSTALL@&$ac_INSTALL&;t t
+s&@MKDIR_P@&$ac_MKDIR_P&;t t
+$ac_datarootdir_hack
+"
+eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$tmp/subs.awk" >$tmp/out \
+  || as_fn_error "could not create $ac_file" "$LINENO" 5
+
+test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
+  { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } &&
+  { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } &&
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
+which seems to be undefined.  Please make sure it is defined." >&5
+$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
+which seems to be undefined.  Please make sure it is defined." >&2;}
+
+  rm -f "$tmp/stdin"
+  case $ac_file in
+  -) cat "$tmp/out" && rm -f "$tmp/out";;
+  *) rm -f "$ac_file" && mv "$tmp/out" "$ac_file";;
+  esac \
+  || as_fn_error "could not create $ac_file" "$LINENO" 5
+ ;;
+  :H)
+  #
+  # CONFIG_HEADER
+  #
+  if test x"$ac_file" != x-; then
+    {
+      $as_echo "/* $configure_input  */" \
+      && eval '$AWK -f "$tmp/defines.awk"' "$ac_file_inputs"
+    } >"$tmp/config.h" \
+      || as_fn_error "could not create $ac_file" "$LINENO" 5
+    if diff "$ac_file" "$tmp/config.h" >/dev/null 2>&1; then
+      { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
+$as_echo "$as_me: $ac_file is unchanged" >&6;}
+    else
+      rm -f "$ac_file"
+      mv "$tmp/config.h" "$ac_file" \
+	|| as_fn_error "could not create $ac_file" "$LINENO" 5
+    fi
+  else
+    $as_echo "/* $configure_input  */" \
+      && eval '$AWK -f "$tmp/defines.awk"' "$ac_file_inputs" \
+      || as_fn_error "could not create -" "$LINENO" 5
+  fi
+# Compute "$ac_file"'s index in $config_headers.
+_am_arg="$ac_file"
+_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" ||
+$as_expr X"$_am_arg" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$_am_arg" : 'X\(//\)[^/]' \| \
+	 X"$_am_arg" : 'X\(//\)$' \| \
+	 X"$_am_arg" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$_am_arg" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`/stamp-h$_am_stamp_count
+ ;;
+
+  :C)  { $as_echo "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5
+$as_echo "$as_me: executing $ac_file commands" >&6;}
+ ;;
+  esac
+
+
+  case $ac_file$ac_mode in
+    "default-1":C)
+# Only add multilib support code if we just rebuilt the top-level
+# Makefile.
+case " $CONFIG_FILES " in
+ *" Makefile "*)
+   ac_file=Makefile . ${multi_basedir}/config-ml.in
+   ;;
+esac ;;
+    "depfiles":C) test x"$AMDEP_TRUE" != x"" || {
+  # Autoconf 2.62 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" ||
+$as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$mf" : 'X\(//\)[^/]' \| \
+	 X"$mf" : 'X\(//\)$' \| \
+	 X"$mf" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$mf" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+    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_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$file" : 'X\(//\)[^/]' \| \
+	 X"$file" : 'X\(//\)$' \| \
+	 X"$file" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$file" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+      as_dir=$dirpart/$fdir; as_fn_mkdir_p
+      # echo "creating $dirpart/$file"
+      echo '# dummy' > "$dirpart/$file"
+    done
+  done
+}
+ ;;
+    "libtool":C)
+
+    # See if we are running on zsh, and set the options which allow our
+    # commands through without removal of \ escapes.
+    if test -n "${ZSH_VERSION+set}" ; then
+      setopt NO_GLOB_SUBST
+    fi
+
+    cfgfile="${ofile}T"
+    trap "$RM \"$cfgfile\"; exit 1" 1 2 15
+    $RM "$cfgfile"
+
+    cat <<_LT_EOF >> "$cfgfile"
+#! $SHELL
+
+# `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services.
+# Generated automatically by $as_me ($PACKAGE$TIMESTAMP) $VERSION
+# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
+# NOTE: Changes made to this file will be lost: look at ltmain.sh.
+#
+#   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,
+#                 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+#   Written by Gordon Matzigkeit, 1996
+#
+#   This file is part of GNU Libtool.
+#
+# GNU Libtool 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.
+#
+# As a special exception to the GNU General Public License,
+# if you distribute this file as part of a program or library that
+# is built using GNU Libtool, you may include this file under the
+# same distribution terms that you use for the rest of that program.
+#
+# GNU Libtool 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 GNU Libtool; see the file COPYING.  If not, a copy
+# can be downloaded from http://www.gnu.org/licenses/gpl.html, or
+# obtained by writing to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+
+# The names of the tagged configurations supported by this script.
+available_tags=""
+
+# ### BEGIN LIBTOOL CONFIG
+
+# Which release of libtool.m4 was used?
+macro_version=$macro_version
+macro_revision=$macro_revision
+
+# Whether or not to build shared libraries.
+build_libtool_libs=$enable_shared
+
+# Whether or not to build static libraries.
+build_old_libs=$enable_static
+
+# What type of objects to build.
+pic_mode=$pic_mode
+
+# Whether or not to optimize for fast installation.
+fast_install=$enable_fast_install
+
+# Shell to use when invoking shell scripts.
+SHELL=$lt_SHELL
+
+# An echo program that protects backslashes.
+ECHO=$lt_ECHO
+
+# The host system.
+host_alias=$host_alias
+host=$host
+host_os=$host_os
+
+# The build system.
+build_alias=$build_alias
+build=$build
+build_os=$build_os
+
+# A sed program that does not truncate output.
+SED=$lt_SED
+
+# Sed that helps us avoid accidentally triggering echo(1) options like -n.
+Xsed="\$SED -e 1s/^X//"
+
+# A grep program that handles long lines.
+GREP=$lt_GREP
+
+# An ERE matcher.
+EGREP=$lt_EGREP
+
+# A literal string matcher.
+FGREP=$lt_FGREP
+
+# A BSD- or MS-compatible name lister.
+NM=$lt_NM
+
+# Whether we need soft or hard links.
+LN_S=$lt_LN_S
+
+# What is the maximum length of a command?
+max_cmd_len=$max_cmd_len
+
+# Object file suffix (normally "o").
+objext=$ac_objext
+
+# Executable file suffix (normally "").
+exeext=$exeext
+
+# whether the shell understands "unset".
+lt_unset=$lt_unset
+
+# turn spaces into newlines.
+SP2NL=$lt_lt_SP2NL
+
+# turn newlines into spaces.
+NL2SP=$lt_lt_NL2SP
+
+# An object symbol dumper.
+OBJDUMP=$lt_OBJDUMP
+
+# Method to check whether dependent libraries are shared objects.
+deplibs_check_method=$lt_deplibs_check_method
+
+# Command to use when deplibs_check_method == "file_magic".
+file_magic_cmd=$lt_file_magic_cmd
+
+# The archiver.
+AR=$lt_AR
+AR_FLAGS=$lt_AR_FLAGS
+
+# A symbol stripping program.
+STRIP=$lt_STRIP
+
+# Commands used to install an old-style archive.
+RANLIB=$lt_RANLIB
+old_postinstall_cmds=$lt_old_postinstall_cmds
+old_postuninstall_cmds=$lt_old_postuninstall_cmds
+
+# Whether to use a lock for old archive extraction.
+lock_old_archive_extraction=$lock_old_archive_extraction
+
+# A C compiler.
+LTCC=$lt_CC
+
+# LTCC compiler flags.
+LTCFLAGS=$lt_CFLAGS
+
+# Take the output of nm and produce a listing of raw symbols and C names.
+global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe
+
+# Transform the output of nm in a proper C declaration.
+global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl
+
+# Transform the output of nm in a C name address pair.
+global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address
+
+# Transform the output of nm in a C name address pair when lib prefix is needed.
+global_symbol_to_c_name_address_lib_prefix=$lt_lt_cv_sys_global_symbol_to_c_name_address_lib_prefix
+
+# The name of the directory that contains temporary libtool files.
+objdir=$objdir
+
+# Used to examine libraries when file_magic_cmd begins with "file".
+MAGIC_CMD=$MAGIC_CMD
+
+# Must we lock files when doing compilation?
+need_locks=$lt_need_locks
+
+# Tool to manipulate archived DWARF debug symbol files on Mac OS X.
+DSYMUTIL=$lt_DSYMUTIL
+
+# Tool to change global to local symbols on Mac OS X.
+NMEDIT=$lt_NMEDIT
+
+# Tool to manipulate fat objects and archives on Mac OS X.
+LIPO=$lt_LIPO
+
+# ldd/readelf like tool for Mach-O binaries on Mac OS X.
+OTOOL=$lt_OTOOL
+
+# ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4.
+OTOOL64=$lt_OTOOL64
+
+# Old archive suffix (normally "a").
+libext=$libext
+
+# Shared library suffix (normally ".so").
+shrext_cmds=$lt_shrext_cmds
+
+# The commands to extract the exported symbol list from a shared archive.
+extract_expsyms_cmds=$lt_extract_expsyms_cmds
+
+# Variables whose values should be saved in libtool wrapper scripts and
+# restored at link time.
+variables_saved_for_relink=$lt_variables_saved_for_relink
+
+# Do we need the "lib" prefix for modules?
+need_lib_prefix=$need_lib_prefix
+
+# Do we need a version for libraries?
+need_version=$need_version
+
+# Library versioning type.
+version_type=$version_type
+
+# Shared library runtime path variable.
+runpath_var=$runpath_var
+
+# Shared library path variable.
+shlibpath_var=$shlibpath_var
+
+# Is shlibpath searched before the hard-coded library search path?
+shlibpath_overrides_runpath=$shlibpath_overrides_runpath
+
+# Format of library name prefix.
+libname_spec=$lt_libname_spec
+
+# List of archive names.  First name is the real one, the rest are links.
+# The last name is the one that the linker finds with -lNAME
+library_names_spec=$lt_library_names_spec
+
+# The coded name of the library, if different from the real name.
+soname_spec=$lt_soname_spec
+
+# Permission mode override for installation of shared libraries.
+install_override_mode=$lt_install_override_mode
+
+# Command to use after installation of a shared archive.
+postinstall_cmds=$lt_postinstall_cmds
+
+# Command to use after uninstallation of a shared archive.
+postuninstall_cmds=$lt_postuninstall_cmds
+
+# Commands used to finish a libtool library installation in a directory.
+finish_cmds=$lt_finish_cmds
+
+# As "finish_cmds", except a single script fragment to be evaled but
+# not shown.
+finish_eval=$lt_finish_eval
+
+# Whether we should hardcode library paths into libraries.
+hardcode_into_libs=$hardcode_into_libs
+
+# Compile-time system search path for libraries.
+sys_lib_search_path_spec=$lt_sys_lib_search_path_spec
+
+# Run-time system search path for libraries.
+sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec
+
+# Whether dlopen is supported.
+dlopen_support=$enable_dlopen
+
+# Whether dlopen of programs is supported.
+dlopen_self=$enable_dlopen_self
+
+# Whether dlopen of statically linked programs is supported.
+dlopen_self_static=$enable_dlopen_self_static
+
+# Commands to strip libraries.
+old_striplib=$lt_old_striplib
+striplib=$lt_striplib
+
+
+# The linker used to build libraries.
+LD=$lt_LD
+
+# How to create reloadable object files.
+reload_flag=$lt_reload_flag
+reload_cmds=$lt_reload_cmds
+
+# Commands used to build an old-style archive.
+old_archive_cmds=$lt_old_archive_cmds
+
+# A language specific compiler.
+CC=$lt_compiler
+
+# Is the compiler the GNU compiler?
+with_gcc=$GCC
+
+# Compiler flag to turn off builtin functions.
+no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag
+
+# How to pass a linker flag through the compiler.
+wl=$lt_lt_prog_compiler_wl
+
+# Additional compiler flags for building library objects.
+pic_flag=$lt_lt_prog_compiler_pic
+
+# Compiler flag to prevent dynamic linking.
+link_static_flag=$lt_lt_prog_compiler_static
+
+# Does compiler simultaneously support -c and -o options?
+compiler_c_o=$lt_lt_cv_prog_compiler_c_o
+
+# Whether or not to add -lc for building shared libraries.
+build_libtool_need_lc=$archive_cmds_need_lc
+
+# Whether or not to disallow shared libs when runtime libs are static.
+allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes
+
+# Compiler flag to allow reflexive dlopens.
+export_dynamic_flag_spec=$lt_export_dynamic_flag_spec
+
+# Compiler flag to generate shared objects directly from archives.
+whole_archive_flag_spec=$lt_whole_archive_flag_spec
+
+# Whether the compiler copes with passing no objects directly.
+compiler_needs_object=$lt_compiler_needs_object
+
+# Create an old-style archive from a shared archive.
+old_archive_from_new_cmds=$lt_old_archive_from_new_cmds
+
+# Create a temporary old-style archive to link instead of a shared archive.
+old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds
+
+# Commands used to build a shared archive.
+archive_cmds=$lt_archive_cmds
+archive_expsym_cmds=$lt_archive_expsym_cmds
+
+# Commands used to build a loadable module if different from building
+# a shared archive.
+module_cmds=$lt_module_cmds
+module_expsym_cmds=$lt_module_expsym_cmds
+
+# Whether we are building with GNU ld or not.
+with_gnu_ld=$lt_with_gnu_ld
+
+# Flag that allows shared libraries with undefined symbols to be built.
+allow_undefined_flag=$lt_allow_undefined_flag
+
+# Flag that enforces no undefined symbols.
+no_undefined_flag=$lt_no_undefined_flag
+
+# Flag to hardcode \$libdir into a binary during linking.
+# This must work even if \$libdir does not exist
+hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec
+
+# If ld is used when linking, flag to hardcode \$libdir into a binary
+# during linking.  This must work even if \$libdir does not exist.
+hardcode_libdir_flag_spec_ld=$lt_hardcode_libdir_flag_spec_ld
+
+# Whether we need a single "-rpath" flag with a separated argument.
+hardcode_libdir_separator=$lt_hardcode_libdir_separator
+
+# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes
+# DIR into the resulting binary.
+hardcode_direct=$hardcode_direct
+
+# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes
+# DIR into the resulting binary and the resulting library dependency is
+# "absolute",i.e impossible to change by setting \${shlibpath_var} if the
+# library is relocated.
+hardcode_direct_absolute=$hardcode_direct_absolute
+
+# Set to "yes" if using the -LDIR flag during linking hardcodes DIR
+# into the resulting binary.
+hardcode_minus_L=$hardcode_minus_L
+
+# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
+# into the resulting binary.
+hardcode_shlibpath_var=$hardcode_shlibpath_var
+
+# Set to "yes" if building a shared library automatically hardcodes DIR
+# into the library and all subsequent libraries and executables linked
+# against it.
+hardcode_automatic=$hardcode_automatic
+
+# Set to yes if linker adds runtime paths of dependent libraries
+# to runtime path list.
+inherit_rpath=$inherit_rpath
+
+# Whether libtool must link a program against all its dependency libraries.
+link_all_deplibs=$link_all_deplibs
+
+# Fix the shell variable \$srcfile for the compiler.
+fix_srcfile_path=$lt_fix_srcfile_path
+
+# Set to "yes" if exported symbols are required.
+always_export_symbols=$always_export_symbols
+
+# The commands to list exported symbols.
+export_symbols_cmds=$lt_export_symbols_cmds
+
+# Symbols that should not be listed in the preloaded symbols.
+exclude_expsyms=$lt_exclude_expsyms
+
+# Symbols that must always be exported.
+include_expsyms=$lt_include_expsyms
+
+# Commands necessary for linking programs (against libraries) with templates.
+prelink_cmds=$lt_prelink_cmds
+
+# Specify filename containing input files.
+file_list_spec=$lt_file_list_spec
+
+# How to hardcode a shared library path into an executable.
+hardcode_action=$hardcode_action
+
+# ### END LIBTOOL CONFIG
+
+_LT_EOF
+
+  case $host_os in
+  aix3*)
+    cat <<\_LT_EOF >> "$cfgfile"
+# AIX sometimes has problems with the GCC collect2 program.  For some
+# reason, if we set the COLLECT_NAMES environment variable, the problems
+# vanish in a puff of smoke.
+if test "X${COLLECT_NAMES+set}" != Xset; then
+  COLLECT_NAMES=
+  export COLLECT_NAMES
+fi
+_LT_EOF
+    ;;
+  esac
+
+
+ltmain="$ac_aux_dir/ltmain.sh"
+
+
+  # We use sed instead of cat because bash on DJGPP gets confused if
+  # if finds mixed CR/LF and LF-only lines.  Since sed operates in
+  # text mode, it properly converts lines to CR/LF.  This bash problem
+  # is reportedly fixed, but why not run on old versions too?
+  sed '/^# Generated shell functions inserted here/q' "$ltmain" >> "$cfgfile" \
+    || (rm -f "$cfgfile"; exit 1)
+
+  case $xsi_shell in
+  yes)
+    cat << \_LT_EOF >> "$cfgfile"
+
+# func_dirname file append nondir_replacement
+# Compute the dirname of FILE.  If nonempty, add APPEND to the result,
+# otherwise set result to NONDIR_REPLACEMENT.
+func_dirname ()
+{
+  case ${1} in
+    */*) func_dirname_result="${1%/*}${2}" ;;
+    *  ) func_dirname_result="${3}" ;;
+  esac
+}
+
+# func_basename file
+func_basename ()
+{
+  func_basename_result="${1##*/}"
+}
+
+# func_dirname_and_basename file append nondir_replacement
+# perform func_basename and func_dirname in a single function
+# call:
+#   dirname:  Compute the dirname of FILE.  If nonempty,
+#             add APPEND to the result, otherwise set result
+#             to NONDIR_REPLACEMENT.
+#             value returned in "$func_dirname_result"
+#   basename: Compute filename of FILE.
+#             value retuned in "$func_basename_result"
+# Implementation must be kept synchronized with func_dirname
+# and func_basename. For efficiency, we do not delegate to
+# those functions but instead duplicate the functionality here.
+func_dirname_and_basename ()
+{
+  case ${1} in
+    */*) func_dirname_result="${1%/*}${2}" ;;
+    *  ) func_dirname_result="${3}" ;;
+  esac
+  func_basename_result="${1##*/}"
+}
+
+# func_stripname prefix suffix name
+# strip PREFIX and SUFFIX off of NAME.
+# PREFIX and SUFFIX must not contain globbing or regex special
+# characters, hashes, percent signs, but SUFFIX may contain a leading
+# dot (in which case that matches only a dot).
+func_stripname ()
+{
+  # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are
+  # positional parameters, so assign one to ordinary parameter first.
+  func_stripname_result=${3}
+  func_stripname_result=${func_stripname_result#"${1}"}
+  func_stripname_result=${func_stripname_result%"${2}"}
+}
+
+# func_opt_split
+func_opt_split ()
+{
+  func_opt_split_opt=${1%%=*}
+  func_opt_split_arg=${1#*=}
+}
+
+# func_lo2o object
+func_lo2o ()
+{
+  case ${1} in
+    *.lo) func_lo2o_result=${1%.lo}.${objext} ;;
+    *)    func_lo2o_result=${1} ;;
+  esac
+}
+
+# func_xform libobj-or-source
+func_xform ()
+{
+  func_xform_result=${1%.*}.lo
+}
+
+# func_arith arithmetic-term...
+func_arith ()
+{
+  func_arith_result=$(( $* ))
+}
+
+# func_len string
+# STRING may not start with a hyphen.
+func_len ()
+{
+  func_len_result=${#1}
+}
+
+_LT_EOF
+    ;;
+  *) # Bourne compatible functions.
+    cat << \_LT_EOF >> "$cfgfile"
+
+# func_dirname file append nondir_replacement
+# Compute the dirname of FILE.  If nonempty, add APPEND to the result,
+# otherwise set result to NONDIR_REPLACEMENT.
+func_dirname ()
+{
+  # Extract subdirectory from the argument.
+  func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`
+  if test "X$func_dirname_result" = "X${1}"; then
+    func_dirname_result="${3}"
+  else
+    func_dirname_result="$func_dirname_result${2}"
+  fi
+}
+
+# func_basename file
+func_basename ()
+{
+  func_basename_result=`$ECHO "${1}" | $SED "$basename"`
+}
+
+
+# func_stripname prefix suffix name
+# strip PREFIX and SUFFIX off of NAME.
+# PREFIX and SUFFIX must not contain globbing or regex special
+# characters, hashes, percent signs, but SUFFIX may contain a leading
+# dot (in which case that matches only a dot).
+# func_strip_suffix prefix name
+func_stripname ()
+{
+  case ${2} in
+    .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
+    *)  func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
+  esac
+}
+
+# sed scripts:
+my_sed_long_opt='1s/^\(-[^=]*\)=.*/\1/;q'
+my_sed_long_arg='1s/^-[^=]*=//'
+
+# func_opt_split
+func_opt_split ()
+{
+  func_opt_split_opt=`$ECHO "${1}" | $SED "$my_sed_long_opt"`
+  func_opt_split_arg=`$ECHO "${1}" | $SED "$my_sed_long_arg"`
+}
+
+# func_lo2o object
+func_lo2o ()
+{
+  func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`
+}
+
+# func_xform libobj-or-source
+func_xform ()
+{
+  func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`
+}
+
+# func_arith arithmetic-term...
+func_arith ()
+{
+  func_arith_result=`expr "$@"`
+}
+
+# func_len string
+# STRING may not start with a hyphen.
+func_len ()
+{
+  func_len_result=`expr "$1" : ".*" 2>/dev/null || echo $max_cmd_len`
+}
+
+_LT_EOF
+esac
+
+case $lt_shell_append in
+  yes)
+    cat << \_LT_EOF >> "$cfgfile"
+
+# func_append var value
+# Append VALUE to the end of shell variable VAR.
+func_append ()
+{
+  eval "$1+=\$2"
+}
+_LT_EOF
+    ;;
+  *)
+    cat << \_LT_EOF >> "$cfgfile"
+
+# func_append var value
+# Append VALUE to the end of shell variable VAR.
+func_append ()
+{
+  eval "$1=\$$1\$2"
+}
+
+_LT_EOF
+    ;;
+  esac
+
+
+  sed -n '/^# Generated shell functions inserted here/,$p' "$ltmain" >> "$cfgfile" \
+    || (rm -f "$cfgfile"; exit 1)
+
+  mv -f "$cfgfile" "$ofile" ||
+    (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")
+  chmod +x "$ofile"
+
+ ;;
+
+  esac
+done # for ac_tag
+
+
+as_fn_exit 0
+_ACEOF
+ac_clean_files=$ac_clean_files_save
+
+test $ac_write_fail = 0 ||
+  as_fn_error "write failure creating $CONFIG_STATUS" "$LINENO" 5
+
+
+# configure is writing to config.log, and then calls config.status.
+# config.status does its own redirection, appending to config.log.
+# Unfortunately, on DOS this fails, as config.log is still kept open
+# by configure, so config.status won't be able to write to it; its
+# output is simply discarded.  So we exec the FD to /dev/null,
+# effectively closing config.log, so it can be properly (re)opened and
+# appended to by config.status.  When coming back to configure, we
+# need to make the FD available again.
+if test "$no_create" != yes; then
+  ac_cs_success=:
+  ac_config_status_args=
+  test "$silent" = yes &&
+    ac_config_status_args="$ac_config_status_args --quiet"
+  exec 5>/dev/null
+  $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
+  exec 5>>config.log
+  # Use ||, not &&, to avoid exiting from the if with $? = 1, which
+  # would make configure fail if this is the last instruction.
+  $ac_cs_success || as_fn_exit $?
+fi
+if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
+$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
+fi
+
diff --git a/liboacc/configure.ac b/liboacc/configure.ac
new file mode 100755
index 00000000000..4f4f9ffaca3
--- /dev/null
+++ b/liboacc/configure.ac
@@ -0,0 +1,193 @@
+
+AC_PREREQ([2.64])
+AC_INIT([OpenACC Runtime Library], [1.0], [dark_beer@rambler.ru])
+
+AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
+LIBOACC_ENABLE(version-specific-runtime-libs, no, ,
+   [Specify that runtime libraries should be installed in a compiler-specific directory],
+   permit yes|no)
+AC_MSG_RESULT($enable_version_specific_runtime_libs)
+
+# We would like our source tree to be readonly. However when releases or
+# pre-releases are generated, the flex/bison generated files as well as the
+# various formats of manuals need to be included along with the rest of the
+# sources.  Therefore we have --enable-generated-files-in-srcdir to do 
+# just that.
+AC_MSG_CHECKING([for --enable-generated-files-in-srcdir])
+LIBOACC_ENABLE(generated-files-in-srcdir, no, ,
+   [put copies of generated files in source dir intended for creating source 
+    tarballs for users without texinfo bison or flex.],
+   permit yes|no)
+AC_MSG_RESULT($enable_generated_files_in_srcdir)
+AM_CONDITIONAL(GENINSRC, test "$enable_generated_files_in_srcdir" = yes)
+
+
+# -------
+# -------
+
+# Gets build, host, target, *_vendor, *_cpu, *_os, etc.
+#
+# You will slowly go insane if you do not grok the following fact:  when
+# building this library, the top-level /target/ becomes the library's /host/.
+#
+# configure then causes --target to default to --host, exactly like any
+# other package using autoconf.  Therefore, 'target' and 'host' will
+# always be the same.  This makes sense both for native and cross compilers
+# just think about it for a little while.  :-)
+#
+# Also, if this library is being configured as part of a cross compiler, the
+# top-level configure script will pass the "real" host as $with_cross_host.
+#
+# Do not delete or change the following two lines.  For why, see
+# http://gcc.gnu.org/ml/libstdc++/2003-07/msg00451.html
+AC_CANONICAL_SYSTEM
+target_alias=${target_alias-$host_alias}
+
+AM_INIT_AUTOMAKE([1.9.0 foreign])
+AM_ENABLE_MULTILIB(, ..)
+
+# Calculate toolexeclibdir
+# Also toolexecdir, though it's only used in toolexeclibdir
+case ${enable_version_specific_runtime_libs} in
+  yes)
+    # Need the gcc compiler version to know where to install libraries
+    # and header files if --enable-version-specific-runtime-libs option
+    # is selected.
+    toolexecdir='$(libdir)/gcc/$(target_alias)'
+    toolexeclibdir='$(toolexecdir)/$(gcc_version)$(MULTISUBDIR)'
+    ;;
+  no)
+    if test -n "$with_cross_host" &&
+       test x"$with_cross_host" != x"no"; then
+      # Install a library built with a cross compiler in tooldir, not libdir.
+      toolexecdir='$(exec_prefix)/$(target_alias)'
+      toolexeclibdir='$(toolexecdir)/lib'
+    else
+      toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
+      toolexeclibdir='$(libdir)'
+    fi
+    multi_os_directory=`$CC -print-multi-os-directory`
+    case $multi_os_directory in
+      .) ;; # Avoid trailing /.
+      *) toolexeclibdir=$toolexeclibdir/$multi_os_directory ;;
+    esac
+    ;;
+esac
+AC_SUBST(toolexecdir)
+AC_SUBST(toolexeclibdir)
+
+AC_CONFIG_SRCDIR([liboacc.c])
+
+# Checks for options.
+opencl=
+openclinc=
+opencllib=
+
+AC_MSG_CHECKING([for OpenCL options])
+AC_ARG_WITH(opencl,
+ [AS_HELP_STRING([--with-opencl=PATH], [specify prefix directory for installed OpenCL SDK.])],
+ [opencl=${withval}])
+AC_ARG_WITH(opencl-include,
+ [AS_HELP_STRING([--with-opencl-include=PATH], [specify directory for installed OpenCL SDK include files])],
+ [openclinc=${withval}])
+AC_ARG_WITH(opencl-lib,
+ [AS_HELP_STRING([--with-opencl-lib=PATH], [specify directory for intalled OpenCL SDK library files])],
+ [opencllib=${withval}])
+
+if test "x$openclinc" == x ; then
+	if test "x$opencl" != x ; then
+		openclinc="${opencl}/include"
+	else
+		AC_MSG_ERROR([This library requires OpenCL SDK path specified in --with-opencl option], 1)
+	fi
+fi
+
+if test "x$opencllib" == x ; then
+	if test "x$opencl" != x ; then
+		opencllib="${opencl}/lib"
+	fi
+fi
+AC_MSG_RESULT([$openclinc])
+
+AC_SUBST(openclinc)
+AC_SUBST(opencllib)
+
+AC_MSG_CHECKING([for thread model used by GCC])
+THREADS=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'`
+if test x"$THREADS" == x; then
+   THREADS=no
+fi
+AC_MSG_RESULT([$THREADS])
+
+# THREADCFLAGS=
+THREADLIBS=
+
+case "$THREADS" in
+ no | none | single)
+    THREADS=none
+    ;;
+ posix | pthreads)
+    THREADS=posix
+    THREADLIBS=-lpthread
+    ;;
+ *)
+    AC_MSG_ERROR($THREADS library is not supported)
+    ;;
+esac
+
+# AC_SUBST(THREADCFLAGS)
+AC_SUBST(THREADLIBS)
+
+
+# Checks for programs.
+AC_PROG_CC
+AC_PROG_INSTALL
+AC_PROG_CC_C_O
+AM_PROG_LIBTOOL
+libtool_VERSION=1:0:0
+AC_SUBST(libtool_VERSION)
+
+# Checks for libraries.
+# Checks for header files.
+AC_CHECK_HEADERS([stdlib.h])
+if test "x$THREADS" == xposix ; then
+AC_CHECK_HEADERS([pthread.h])
+fi
+
+# Checks for typedefs, structures, and compiler characteristics.
+AC_TYPE_SIZE_T
+
+# Checks for library functions.
+AC_FUNC_MALLOC
+
+save_CFLAGS="$CFLAGS"
+
+CFLAGS="$CFLAGS -I$openclinc"
+AC_COMPILE_IFELSE(
+ [AC_LANG_PROGRAM(
+  [#if __CYGWIN__ && !_WIN32
+   #define _WIN32 1
+   #endif
+   #ifdef MAC
+   #include <OpenCL/cl.h>
+   #else  
+   #include <CL/cl.h>
+   #endif
+   ],
+  [cl_platform_id platform; clGetPlatformIDs(1, &platform, NULL);])],
+ [], [AC_MSG_ERROR([OpenCL SDK must be installed to build liboacc library])])
+
+if test "x$THREADS" == xposix ; then
+CFLAGS="$CFLAGS -pthread"
+AC_COMPILE_IFELSE(
+  [AC_LANG_PROGRAM(
+    [#include <pthread.h>
+     void *f(void *d) { return NULL; }],
+    [pthread_t t; pthread_create(&t,NULL,f,NULL);])],
+  [], [AC_MSG_ERROR([Compiler configured to use posix threads but header file is missing])])
+fi
+
+CFLAGS="$save_CFLAGS"
+AC_CONFIG_HEADERS([config.h])
+AC_CONFIG_FILES([Makefile liboacc.spec])
+AC_OUTPUT
diff --git a/liboacc/liboacc-internal.h b/liboacc/liboacc-internal.h
new file mode 100755
index 00000000000..276cbf785d9
--- /dev/null
+++ b/liboacc/liboacc-internal.h
@@ -0,0 +1,272 @@
+/* 
+This file is part of GCC.
+
+GCC 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 3, or (at your option) any later
+version.
+
+GCC 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 GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+/* LIBOACC internals */
+
+#ifndef LIBOACC_INTERNAL_H
+#define LIBOACC_INTERNAL_H
+
+#if __CYGWIN__ && !_WIN32
+#define _WIN32 1
+#endif
+
+#include <stdlib.h>
+#ifdef HAVE_PTHREAD_H
+#include <pthread.h>
+#define PHTREAD_LOCKS
+#endif
+
+
+#ifdef MAC
+#include <OpenCL/cl.h>
+#else  
+#include <CL/cl.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef PTHREAD_LOCKS
+
+#define LOCK_DECLARE(m)			pthread_murex_t m
+#define LOCK_DECLARE_EX(m)	extern pthread_murex_t m = PTHREAD_MUTEX_INITIALIZER
+#define LOCK_INIT(m)				pthread_mutex_init(&m, NULL)
+#define LOCK_AQUIRE(m)			pthread_mutex_lock(&m)
+#define LOCK_RELEASE(m)			pthread_mutex_unlock(&m)
+#define LOCK_DESTROY(m)			pthread_mutex_destroy(&m)
+
+#else /* single threaded */
+
+#define LOCK_DECLARE(m)
+#define LOCK_DECLARE_EX(m)
+#define LOCK_INIT(m)
+#define LOCK_AQUIRE(m)
+#define LOCK_RELEASE(m)
+#define LOCK_DESTROY(m)
+
+#endif
+
+enum OACC_queue_status {
+	OACC_QS_RUNNING,
+	OACC_QS_READY,
+	OACC_QS_COMPLETE
+};
+
+typedef struct OACC_event_data* OACC_event_ptr;
+
+struct OACC_event_data
+{
+	int kind;
+	cl_uint nevents;
+	cl_event* events;
+	OACC_event_ptr next;
+	OACC_event_ptr prev;
+};
+
+struct OACC_queue_data
+{
+	int cookie;
+	const char* source_file;
+	int source_line;
+	OACC_event_ptr head, tail, curr;
+	struct OACC_queue_data* next;
+	LOCK_DECLARE(queue_lock);
+};
+
+#define OACC_EQ_WAIT_COUNT(q)			((q->curr->prev != NULL) ? q->curr->prev->nevents : 0)
+#define OACC_EQ_WAIT_PTR(q)				((q->curr->prev != NULL) ? q->curr->prev->events : NULL)
+#define OACC_EQ_SET_PTR(q, i)			((i < q->curr->nevents) ? q->curr->events + i : NULL)
+#define OACC_EQ_EVENTS(q,n,w,s,i)	if(q != NULL && q->curr != NULL) { \
+																		n = OACC_EQ_WAIT_COUNT(q); \
+																		w = OACC_EQ_WAIT_PTR(q); \
+																		s = OACC_EQ_SET_PTR(q, i); \
+																	}
+#define OACC_EQ_ADVANCE(q)			if(q != NULL && q->curr != NULL && q->curr->next != NULL) {\
+																	q->curr = q->curr->next; \
+																}
+#define OACC_EQ_FIRE_EVENT(q,i,d)	if(q != NULL && q->curr != NULL && i < q->curr->nevents) {\
+																		OACC_fire_event(q, i, d); \
+																}
+
+struct OACC_async_data
+{
+	struct OACC_queue_data *named, *nameless;
+};
+
+#define OACC_BF(n)				(1<<n)
+#define OACC_BF_PRESENT		OACC_BF(0)
+#define OACC_BF_DEV_ONLY	OACC_BF(1)
+#define OACC_BF_MAPPED		OACC_BF(2)
+
+/*
+argument data represented as OpenCL memory buffer
+*/
+struct OACC_buffer_data
+{
+	cl_mem mem_obj;
+	unsigned flags;
+	void* data_ptr; /* not an owner! DO NOT free */
+	size_t data_size;
+	struct OACC_buffer_data* next;
+};
+
+typedef struct OACC_buffer_data* OACC_buffer_ptr;
+
+/*
+element of kernels linked list
+*/
+struct OACC_kernel_data
+{
+	cl_kernel kern;
+	char* name; /* cached name to avoid reloading */
+
+	size_t nargs;
+	OACC_buffer_ptr* args;
+	struct OACC_kernel_data* next;
+};
+
+/*
+element of programs linked list
+*/
+struct OACC_program_data
+{
+	cl_program prog;
+	char* name; /*cached name to avoid reloading */
+
+	struct OACC_kernel_data *kern_head;
+	struct OACC_program_data *next;
+};
+
+#define OACC_DF(n)						(1<<n)
+#define OACC_DF_OUT_OF_ORDER	OACC_DF(0)
+#define OACC_DF_UNIFIED_MEM		OACC_DF(1)
+#define OACC_DEF_PROFILING		OACC_DF(2)
+
+enum OACC_vec_type_idx {
+	OACC_IDX_CHAR, OACC_IDX_SHORT, OACC_IDX_INT,
+	OACC_IDX_LONG, OACC_IDX_FLOAT, OACC_IDX_DOUBLE,
+	OACC_IDX_HALF, OACC_TYPE_LAST
+};
+
+enum OACC_vec_kind_idx {
+	OACC_IDX_NATIVE, OACC_IDX_PREF, OACC_KIND_LAST
+};
+
+/*
+data per OpenCL device
+*/
+struct OACC_device_data
+{
+	cl_device_id id;
+	cl_device_type type; 	/* cached device type */
+	unsigned flags;
+	cl_uint max_comp_units;
+	cl_uint max_wi_dims;
+	size_t *max_wi_sizes;
+	size_t max_wg_size;
+	cl_ulong max_alloc, glob_mem_size, const_mem_size, loc_mem_size;
+	cl_uint vec_size[OACC_TYPE_LAST][OACC_KIND_LAST];
+	cl_command_queue queue;
+	cl_context ctx;				/* one device per context */
+	struct OACC_program_data *prog_head;
+	OACC_buffer_ptr mem;
+	LOCK_DECLARE(dev_lock);
+};
+
+typedef struct OACC_device_data* OACC_device_ptr;
+
+/*
+data per OpenCL platform
+*/
+struct OACC_platform_data
+{
+	cl_platform_id id;
+
+	size_t ndevs;
+	struct OACC_device_data* devs;
+};
+
+/* global platforms array */
+extern size_t OACC_nplatforms;
+extern struct OACC_platform_data* OACC_platforms;
+
+extern struct OACC_async_data OACC_async;
+
+/* arrays of pointers to device data in order to implement OpenACC get/set device facility */
+extern size_t OACC_nhost_devs, OACC_nacc_devs, OACC_curr_num, OACC_host_num, OACC_acc_num;
+extern OACC_device_ptr *OACC_host_devs, *OACC_acc_devs, *OACC_default_dev, *OACC_curr_dev;
+
+extern long long OACC_read_time, OACC_write_time, OACC_exec_time;
+extern int OACC_profiling;
+
+LOCK_DECLARE_EX(OACC_dev_lock);
+LOCK_DECLARE_EX(OACC_async_lock);
+LOCK_DECLARE_EX(OACC_profile_lock);
+
+/* environment initialization/cleanup */
+extern void OACC_env_init(void);
+extern void OACC_env_fini(void);
+/* device initialization / cleanup */
+extern void OACC_dev_init(OACC_device_ptr pdev);
+extern void OACC_dev_fini(OACC_device_ptr pdev);
+
+#define OACC_CHECK_INIT								if(OACC_platforms == NULL) OACC_env_init();
+#define OACC_CHECK_DEV_INIT(dev_ptr)	if((dev_ptr)->ctx == NULL || (dev_ptr)->queue == NULL) OACC_dev_init(dev_ptr);
+#define OACC_CHECK_KERN_PTR(kern)			if(kern == NULL) return;
+
+/* runtime support for OpenACC codegen */
+extern struct OACC_kernel_data* OACC_find_kernel(const char* prog_name, const char* kern_name);
+extern void OACC_enqueue_kernel(struct OACC_kernel_data* kern, unsigned worksize, struct OACC_queue_data* queue, unsigned idx);
+extern void OACC_set_arg_buf(struct OACC_kernel_data* kern, unsigned idx, OACC_buffer_ptr buf);
+
+/* memory biffers management */
+extern OACC_buffer_ptr OACC_create_or_copy_to_device(void *ptr, size_t size, OACC_device_ptr dev_ptr, int chk_present, int dev_only, struct OACC_queue_data* queue, unsigned idx);
+extern void OACC_copy_from_device(void *ptr, size_t size, OACC_device_ptr dev_ptr, int chk_present, struct OACC_queue_data* queue, unsigned idx);
+extern OACC_buffer_ptr OACC_is_present(void *ptr, OACC_device_ptr dev_ptr);
+
+/* memory allocation on device */
+extern OACC_buffer_ptr OACC_alloc_on_device(void *host_ptr, size_t size, OACC_device_ptr dev_ptr, int dev_only);
+extern void OACC_free_device_mem(void* ptr, OACC_device_ptr dev_ptr);
+
+/* async management */
+extern struct OACC_queue_data* OACC_create_queue(const char* src, int lineno);
+extern void OACC_add_event(struct OACC_queue_data* queue, unsigned n, int kind);
+extern void OACC_wait_queue(struct OACC_queue_data* queue);
+extern void OACC_fire_event(struct OACC_queue_data* queue, unsigned i, OACC_device_ptr dev_ptr);
+extern void OACC_add_queue_with_name(struct OACC_queue_data* queue, int name);
+extern void OACC_add_queue_without_name(struct OACC_queue_data* queue);
+extern struct OACC_queue_data* OACC_find_queue(int cookie, struct OACC_queue_data** pprev);
+extern void OACC_wait_all_global_queues(void);
+extern enum OACC_queue_status OACC_test_queue(struct OACC_queue_data* queue);
+extern int OACC_test_all_global_queues(void);
+struct OACC_queue_data* OACC_unlink_queue(struct OACC_queue_data** plist, struct OACC_queue_data* prev);
+
+#define OACC_PF_DATAIN	1
+#define OACC_PF_EXEC		2
+#define OACC_PF_DATAOUT	3
+
+extern void OACC_profiling_enable(void);
+
+extern void OACC_fatal(const char* msg, ...);
+extern void OACC_warning(const char* msg, ...);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/liboacc/liboacc.c b/liboacc/liboacc.c
new file mode 100755
index 00000000000..f012297aaae
--- /dev/null
+++ b/liboacc/liboacc.c
@@ -0,0 +1,178 @@
+/* 
+This file is part of GCC.
+
+GCC 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 3, or (at your option) any later
+version.
+
+GCC 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 GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+
+#include "liboacc.h"
+#include "liboacc-internal.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int
+get_global_id(int id)
+{
+    fprintf(stderr, "get_global_id is for device only!\n");
+    exit(1);
+}
+
+/* make sure current device initialized */
+void
+OACC_check_cur_dev(void)
+{
+	OACC_CHECK_INIT
+	if(OACC_curr_dev != NULL) {
+		OACC_CHECK_DEV_INIT(OACC_curr_dev[OACC_curr_num])
+	}
+}
+
+/* get function KERN_NAME form module PROG_NAME */
+oacc_kernel
+OACC_get_kernel(const char* prog_name, const char* kern_name)
+{
+	OACC_CHECK_INIT
+	OACC_CHECK_DEV_INIT(OACC_curr_dev[OACC_curr_num])
+	return (oacc_kernel)OACC_find_kernel(prog_name, kern_name);
+}
+
+/* enqueue kernel KERN for WORKSIZE threads */
+void
+OACC_start_kernel(oacc_kernel kern, unsigned worksize, oacc_event ev, unsigned idx)
+{
+	OACC_CHECK_KERN_PTR(kern)
+	OACC_CHECK_INIT
+	OACC_CHECK_DEV_INIT(OACC_curr_dev[OACC_curr_num])
+	OACC_enqueue_kernel((struct OACC_kernel_data*)kern, worksize, (struct OACC_queue_data*)ev, idx);
+}
+
+oacc_buffer
+OACC_copyin(void *mem, unsigned size, int check_present, oacc_event ev, unsigned idx)
+{
+	OACC_CHECK_INIT
+	OACC_CHECK_DEV_INIT(OACC_curr_dev[OACC_curr_num])
+	return (oacc_buffer)OACC_create_or_copy_to_device(mem, size, OACC_curr_dev[OACC_curr_num], check_present, 0, (struct OACC_queue_data*)ev, idx);
+}
+
+void
+OACC_set_kernel_arg(oacc_kernel kern, unsigned idx, oacc_buffer buf)
+{
+	OACC_CHECK_KERN_PTR(kern)
+	OACC_CHECK_INIT
+	OACC_CHECK_DEV_INIT(OACC_curr_dev[OACC_curr_num])
+	OACC_set_arg_buf((struct OACC_kernel_data*)kern, idx, (OACC_buffer_ptr)buf);
+}
+
+oacc_buffer
+OACC_check_present(void *mem)
+{
+	OACC_buffer_ptr buf = 0;
+	OACC_CHECK_INIT
+	OACC_CHECK_DEV_INIT(OACC_curr_dev[OACC_curr_num])
+	if((buf = OACC_is_present(mem, OACC_curr_dev[OACC_curr_num])) == NULL) {
+		OACC_fatal("Required data not present");
+	}
+	return buf;
+}
+
+oacc_buffer
+OACC_create_on_device(void* mem, unsigned size, int check_present, oacc_event ev, unsigned idx)
+{
+	OACC_CHECK_INIT
+	OACC_CHECK_DEV_INIT(OACC_curr_dev[OACC_curr_num])
+	return (oacc_buffer)OACC_create_or_copy_to_device(mem, size, OACC_curr_dev[OACC_curr_num], check_present, 1, (struct OACC_queue_data*)ev, idx);
+}
+
+void
+OACC_copyout(void *mem, unsigned size, int check_present, oacc_event ev, unsigned idx)
+{
+	OACC_CHECK_INIT
+	OACC_CHECK_DEV_INIT(OACC_curr_dev[OACC_curr_num])
+	OACC_copy_from_device(mem, size, OACC_curr_dev[OACC_curr_num], check_present, (struct OACC_queue_data*)ev, idx);
+}
+
+oacc_event
+OACC_create_events(const char* src, int lineno)
+{
+	return (oacc_event)OACC_create_queue(src, lineno);
+}
+
+void
+OACC_enqueue_events(oacc_event ev, unsigned n, int k)
+{
+	OACC_add_event((struct OACC_queue_data*)ev, n, k);
+}
+
+void
+OACC_advance_events(oacc_event ev)
+{
+	struct OACC_queue_data* q = (struct OACC_queue_data*)ev;
+	OACC_EQ_ADVANCE(q)
+}
+
+void
+OACC_wait_events(oacc_event ev)
+{
+	OACC_wait_queue((struct OACC_queue_data*)ev);
+}
+
+void
+OACC_add_named_async(int cookie, oacc_event ev)
+{
+	struct OACC_queue_data* q = (struct OACC_queue_data*)ev;
+	OACC_CHECK_INIT
+	OACC_add_queue_with_name(q, cookie);
+}
+
+void
+OACC_add_nameless_async(oacc_event ev)
+{
+	struct OACC_queue_data* q = (struct OACC_queue_data*)ev;
+	OACC_CHECK_INIT
+	OACC_add_queue_without_name(q);
+}
+
+void
+OACC_wait_named_async(int cookie)
+{
+	struct OACC_queue_data *q = NULL, *qprev = NULL;
+	OACC_CHECK_INIT
+	q = OACC_find_queue(cookie, &qprev);
+	if(q != NULL) {
+		OACC_unlink_queue(&OACC_async.named, qprev);
+		OACC_wait_queue(q);
+	}
+}
+
+void
+OACC_wait_all_async()
+{
+	OACC_CHECK_INIT
+	OACC_wait_all_global_queues();
+}
+
+void
+OACC_start_profiling(void)
+{
+	OACC_profiling_enable();
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/liboacc/liboacc.h b/liboacc/liboacc.h
new file mode 100755
index 00000000000..288e79abe88
--- /dev/null
+++ b/liboacc/liboacc.h
@@ -0,0 +1,83 @@
+/* 
+This file is part of GCC.
+
+GCC 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 3, or (at your option) any later
+version.
+
+GCC 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 GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+/*
+functions generated by OpenACC implementation
+in the place of directives
+*/
+
+#ifndef LIBOACC_H
+#define LIBOACC_H
+
+#if __CYGWIN__ && !_WIN32
+#define _WIN32 1
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+int get_global_id(int);
+
+/* handles to various internel objects */
+typedef void* oacc_kernel;
+typedef void* oacc_buffer;
+typedef void* oacc_event;
+
+/* make sure environment and device initialized */
+void OACC_check_cur_dev(void);
+/* create or get kernel from cache */
+oacc_kernel OACC_get_kernel(const char* prog_name, const char* kern_name);
+/* start a kernel with specified worksize */
+void OACC_start_kernel(oacc_kernel kernel, unsigned worksize, oacc_event ev, unsigned ev_idx);
+/* associate memory object with kernel argument */
+void OACC_set_kernel_arg(oacc_kernel kern, unsigned idx, oacc_buffer buf);
+
+/* copy memory object to device */
+oacc_buffer OACC_copyin(void *mem, unsigned size, int check_present, oacc_event ev, unsigned ev_idx);
+/* check object presence on device */
+oacc_buffer OACC_check_present(void *mem);
+/* create memory object on device */
+oacc_buffer OACC_create_on_device(void* mem, unsigned size, int check_present, oacc_event ev, unsigned ev_idx);
+/* copy memory object to host */
+void OACC_copyout(void *mem, unsigned size, int check_present, oacc_event ev, unsigned ev_idx);
+
+/* create synchro queue */
+oacc_event OACC_create_events(const char* src, int lineno);
+/* set one step of processing */
+void OACC_enqueue_events(oacc_event ev, unsigned n, int k);
+/* advance on next step */
+void OACC_advance_events(oacc_event ev);
+/* synchronize */
+void OACC_wait_events(oacc_event ev);
+
+/* create or add global named async */
+void OACC_add_named_async(int cookie, oacc_event ev);
+/* create global nameless async */
+void OACC_add_nameless_async(oacc_event ev);
+/* wait specified async */
+void OACC_wait_named_async(int cookie);
+/* wait all async */
+void OACC_wait_all_async(void);
+
+void OACC_start_profiling(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/liboacc/liboacc.spec.in b/liboacc/liboacc.spec.in
new file mode 100755
index 00000000000..6c2b0baa0e1
--- /dev/null
+++ b/liboacc/liboacc.spec.in
@@ -0,0 +1,3 @@
+# This spec file is read by gcc when linking. It is used to specify the
+# libraries we need in order to link with -fopenacc.
+*link_oacc: -loacc -L@opencllib@ -lOpenCL
diff --git a/liboacc/memory.c b/liboacc/memory.c
new file mode 100755
index 00000000000..7e046d23783
--- /dev/null
+++ b/liboacc/memory.c
@@ -0,0 +1,266 @@
+/* 
+This file is part of GCC.
+
+GCC 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 3, or (at your option) any later
+version.
+
+GCC 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 GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+/* memory management for OpenACC */
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include "liboacc-internal.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* find device buffer object that corresponds to host PTR.
+	PPREV can be non NULL, in this case previous pointer returned in it.
+*/
+static OACC_buffer_ptr
+OACC_find_buffer(void *ptr, OACC_device_ptr dev_ptr, OACC_buffer_ptr* pprev)
+{
+	OACC_buffer_ptr buf = NULL, prev = NULL;
+
+	LOCK_AQUIRE(dev_ptr->dev_lock);
+	for(prev = buf = dev_ptr->mem; buf != NULL; prev = buf, buf = buf->next) {
+		if(buf->data_ptr == ptr) {
+			if(pprev != NULL) {
+				*pprev = prev;
+			}
+			break;
+		}
+	}
+	LOCK_RELEASE(dev_ptr->dev_lock);
+	return buf;
+}
+
+/* add buffer BUF_PTR to linked list on device pointed by DEV_PTR */
+static void
+OACC_attach_buffer(OACC_device_ptr dev_ptr, OACC_buffer_ptr buf_ptr)
+{
+	LOCK_AQUIRE(dev_ptr->dev_lock);
+	buf_ptr->next = dev_ptr->mem;
+	dev_ptr->mem = buf_ptr;
+	LOCK_RELEASE(dev_ptr->dev_lock);
+}
+
+/* remove buffer that is next to given PREV_PTR from device linked list */
+static OACC_buffer_ptr
+OACC_detach_buffer(OACC_device_ptr dev_ptr, OACC_buffer_ptr prev_ptr)
+{
+	OACC_buffer_ptr buf = NULL;
+
+	if(prev_ptr == NULL) {
+		return NULL;
+	}
+
+	LOCK_AQUIRE(dev_ptr->dev_lock);
+	buf = prev_ptr->next;
+	if(prev_ptr == dev_ptr->mem) {
+		dev_ptr->mem = buf->next;
+	}
+	else {
+		prev_ptr->next = buf->next;
+	}
+	LOCK_RELEASE(dev_ptr->dev_lock);
+	return buf;
+}
+
+/* allocate on device DEV_PTR SIZE bytes of memory */
+OACC_buffer_ptr
+OACC_alloc_on_device(void *host_ptr, size_t size, OACC_device_ptr dev_ptr, int dev_only)
+{
+	cl_int err;
+	cl_mem mem_obj;
+	OACC_buffer_ptr buff = NULL;
+	cl_mem_flags mem_flags = CL_MEM_READ_WRITE;
+	unsigned buf_flags = 0;
+
+	if(host_ptr != NULL && dev_only == 0) {
+		mem_flags |= ((dev_ptr->flags & OACC_DF_UNIFIED_MEM) != 0) ? CL_MEM_USE_HOST_PTR : CL_MEM_COPY_HOST_PTR;
+	}
+
+	mem_obj = clCreateBuffer(dev_ptr->ctx, mem_flags, size, host_ptr, &err);
+	if(err < 0) {
+		OACC_fatal("Can't create memory buffer: %d\n", err);
+	}
+
+	if(host_ptr == NULL && dev_only == 0) {
+		host_ptr = clEnqueueMapBuffer(dev_ptr->queue, mem_obj, CL_TRUE, CL_MAP_READ | CL_MAP_WRITE, 0, size, 0, NULL, NULL, &err);
+		if(err < 0) {
+			OACC_fatal("Can't map memory buffer: %d\n", err);
+		}
+		buf_flags |= OACC_BF_MAPPED;
+	}
+
+	if(dev_only != 0) {
+		buf_flags |= OACC_BF_DEV_ONLY;
+	}
+
+	buff = (OACC_buffer_ptr)calloc(1, sizeof(struct OACC_buffer_data));
+	if(buff == NULL) {
+		OACC_fatal("Not enough memory for buffer\n");
+	}
+
+	buff->mem_obj = mem_obj;
+	buff->data_size = size;
+	buff->data_ptr = host_ptr;
+	buff->flags = buf_flags;
+	OACC_attach_buffer(dev_ptr, buff);
+	return buff;
+}
+
+/* free memory on device */
+void
+OACC_free_device_mem(void* ptr, OACC_device_ptr dev_ptr)
+{
+	OACC_buffer_ptr buf = NULL, prev = NULL;
+	cl_int err;
+
+
+	buf = OACC_find_buffer(ptr, dev_ptr, &prev);
+	if(buf == NULL) {
+		return;
+	}
+
+	if((buf->flags & OACC_BF_MAPPED) != 0) {
+		if((err = clEnqueueUnmapMemObject(dev_ptr->queue, buf->mem_obj, buf->data_ptr, 0, NULL, NULL)) < 0) {
+			OACC_fatal("Can't unmap memory buffer: %d\n", err);
+		}
+	}
+	clReleaseMemObject(buf->mem_obj);
+
+	OACC_detach_buffer(dev_ptr, prev);
+	free(buf);
+}
+
+/* attach memory obect as IDX argument of kernel KERN */
+void
+OACC_set_arg_buf(struct OACC_kernel_data* kern, unsigned idx, OACC_buffer_ptr buf)
+{
+	cl_int err;
+
+	if(idx >= kern->nargs) {
+		return;
+	}
+
+	kern->args[idx] = buf;
+	if((err = clSetKernelArg(kern->kern , idx, sizeof(cl_mem), &buf->mem_obj)) < 0) {
+		OACC_fatal("Can't set kernel argument: %d\n", err);
+	}
+}
+
+/* assure presence of host memory object on device */
+OACC_buffer_ptr
+OACC_create_or_copy_to_device(void *ptr, size_t size, OACC_device_ptr dev_ptr, int chk_present, int dev_only, struct OACC_queue_data* queue, unsigned idx)
+{
+	OACC_buffer_ptr buf = NULL;
+	cl_uint nev;
+	cl_event *ev_wait = NULL, *ev_set = NULL;
+
+	OACC_EQ_EVENTS(queue, nev, ev_wait, ev_set, idx)
+
+	if(chk_present && (buf = OACC_is_present(ptr, dev_ptr)) != NULL) {
+		OACC_EQ_FIRE_EVENT(queue, idx, dev_ptr)
+		return buf;
+	}
+	
+	buf = OACC_find_buffer(ptr, dev_ptr, NULL);
+	if(buf == NULL) {
+		buf = OACC_alloc_on_device(ptr, size, dev_ptr, dev_only);
+	}
+
+	if(ptr != NULL && dev_only == 0) {
+		if((buf->flags & OACC_BF_MAPPED) != 0 && ptr != buf->data_ptr) {
+			memcpy(buf->data_ptr, ptr, size);
+			OACC_EQ_FIRE_EVENT(queue, idx, dev_ptr)
+		}
+		else {
+#ifdef UNIFIED_MEM_OPT
+			if((dev_ptr->flags & OACC_DF_UNIFIED_MEM) != 0) {
+				OACC_EQ_FIRE_EVENT(queue, idx, dev_ptr)
+			}
+			else {
+#endif
+				cl_int err;
+
+				err = clEnqueueWriteBuffer(dev_ptr->queue, buf->mem_obj,
+					CL_FALSE, 0, size, ptr, nev, ev_wait, ev_set);
+				if(err < 0) {
+					OACC_fatal("Can't enqueue write buffer: %d\n", err);
+				}
+#ifdef UNIFIED_MEM_OPT
+			}
+#endif
+		}
+		buf->flags |= OACC_BF_PRESENT;
+	}
+
+	return buf;
+}
+
+/* copy device memory object back to host */
+void
+OACC_copy_from_device(void *ptr, size_t size, OACC_device_ptr dev_ptr, int chk_present, struct OACC_queue_data* queue, unsigned idx)
+{
+	OACC_buffer_ptr buf = NULL;
+	cl_uint nev;
+	cl_event *ev_wait = NULL, *ev_set = NULL;
+
+	OACC_EQ_EVENTS(queue, nev, ev_wait, ev_set, idx)
+
+	buf = OACC_find_buffer(ptr, dev_ptr, NULL);
+	if(buf != NULL) {
+		if((buf->flags & OACC_BF_MAPPED) != 0 && ptr != buf->data_ptr) {
+			memcpy(ptr, buf->data_ptr, size);
+			OACC_EQ_FIRE_EVENT(queue, idx, dev_ptr)
+		}
+		else {
+#ifdef UNIFIED_MEM_OPT
+			if((dev_ptr->flags & OACC_DF_UNIFIED_MEM) != 0) {
+				OACC_EQ_FIRE_EVENT(queue, idx, dev_ptr)
+			}
+			else {
+#endif
+				cl_int err;
+
+				err = clEnqueueReadBuffer(dev_ptr->queue, buf->mem_obj, 
+					CL_FALSE, 0, size, ptr, nev, ev_wait, ev_set);
+				if(err < 0) {
+					OACC_fatal("Can't enqueue read buffer: %d\n", err);
+				}
+#ifdef UNIFIED_MEM_OPT
+			}
+#endif
+		}
+	}
+}
+
+/* check memory object presence on device */
+OACC_buffer_ptr
+OACC_is_present(void *ptr, OACC_device_ptr dev_ptr)
+{
+	OACC_buffer_ptr buf = OACC_find_buffer(ptr, dev_ptr, NULL);
+
+	if(buf == NULL) {
+		return NULL;
+	}
+
+	return (buf->flags & OACC_BF_PRESENT) ? buf : NULL;
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/liboacc/openacc.c b/liboacc/openacc.c
new file mode 100755
index 00000000000..6da34fa9b63
--- /dev/null
+++ b/liboacc/openacc.c
@@ -0,0 +1,279 @@
+/* 
+This file is part of GCC.
+
+GCC 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 3, or (at your option) any later
+version.
+
+GCC 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 GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+#include "openacc.h"
+#include "liboacc-internal.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+in current implementation acc_device_default treated always like acc_device_not_host
+*/
+
+int
+acc_get_num_devices(acc_device_t devt)
+{
+	OACC_CHECK_INIT
+	switch(devt) {
+		case acc_device_host:
+			return OACC_nhost_devs;
+		case acc_device_not_host:
+		case acc_device_default:
+			return OACC_nacc_devs;
+	}
+	return 0;
+}
+
+void
+acc_set_device_type(acc_device_t devt)
+{
+	OACC_CHECK_INIT
+	LOCK_AQUIRE(OACC_dev_lock);
+	switch(devt) {
+		case acc_device_host:
+			OACC_curr_dev = OACC_host_devs;
+			OACC_curr_num = OACC_host_num;
+			break;
+		case acc_device_not_host:
+		case acc_device_default:
+			OACC_curr_dev = OACC_acc_devs;
+			OACC_curr_num = OACC_acc_num;
+			break;
+		default:
+			OACC_curr_dev = NULL;
+			OACC_curr_num = 0;
+			break;
+	}
+	LOCK_RELEASE(OACC_dev_lock);
+}
+
+acc_device_t
+acc_get_device_type(void)
+{
+	acc_device_t ret = acc_device_none;
+
+	OACC_CHECK_INIT
+	LOCK_AQUIRE(OACC_dev_lock);
+	if(OACC_curr_dev == OACC_host_devs) {
+		ret = acc_device_host;
+	}
+	else if(OACC_curr_dev == OACC_acc_devs) {
+		ret = acc_device_not_host;
+	}
+	LOCK_RELEASE(OACC_dev_lock);
+	return ret;
+}
+
+/*
+according to OpenACC standard, NUM == 0 means default device of specified type,
+DEVT == 0 means for all device types
+*/
+void
+acc_set_device_num(int num, acc_device_t devt)
+{
+	if(num < 0) {
+		return;
+	}
+	OACC_CHECK_INIT
+	LOCK_AQUIRE(OACC_dev_lock);
+
+	/* make first device of type default device */
+	if(num == 0) {
+		++num;
+	}
+
+	/*
+	we maintain number of current device as an index into corresponding array,
+	so before update internal data given number must be decremented
+	*/
+	switch(devt) {
+		case acc_device_none:
+			if(num > OACC_nhost_devs) {
+				num = OACC_nhost_devs;
+			}
+			if(num > OACC_nacc_devs) {
+				num = OACC_nacc_devs;
+			}
+			OACC_host_num = OACC_acc_num = num - 1;
+			break;
+		case acc_device_host:
+			if(num > OACC_nhost_devs) {
+				num = OACC_nhost_devs;
+			}
+			OACC_host_num = num - 1;
+			break;
+		case acc_device_default:
+		case acc_device_not_host:
+			if(num > OACC_nacc_devs) {
+				num = OACC_nacc_devs;
+			}
+			OACC_acc_num = num - 1;
+			break;
+	}
+	/* update current device index */
+	if(OACC_curr_dev == OACC_host_devs) {
+		OACC_curr_num = OACC_host_num;
+	}
+	else if(OACC_curr_dev == OACC_acc_devs) {
+		OACC_curr_num = OACC_acc_num;
+	}
+
+	LOCK_RELEASE(OACC_dev_lock);
+}
+
+int
+acc_get_device_num(acc_device_t devt)
+{
+	OACC_CHECK_INIT
+	switch(devt) {
+		case acc_device_host:
+			return OACC_host_num + 1;
+		case acc_device_default:
+		case acc_device_not_host:
+			return OACC_acc_num + 1;
+	}
+	return -1;
+}
+
+/* device explicit initialization / cleanup */
+void
+acc_init(acc_device_t devt)
+{
+	size_t i, n;
+	OACC_device_ptr *ptbl = NULL;
+
+	OACC_CHECK_INIT
+	switch(devt) {
+		case acc_device_host:
+			ptbl = OACC_host_devs;
+			n = OACC_nhost_devs;
+			break;
+		case acc_device_default:
+		case acc_device_not_host:
+			ptbl = OACC_acc_devs;
+			n = OACC_nacc_devs;
+			break;
+	}
+
+	LOCK_AQUIRE(OACC_dev_lock);
+	if(ptbl != NULL && n > 0) {
+		for(i = 0 ; i < n; ++i) {
+			OACC_dev_init(ptbl[i]);
+		}
+	}
+	LOCK_RELEASE(OACC_dev_lock);
+}
+
+void
+acc_shutdown(acc_device_t devt)
+{
+	size_t i, n;
+	OACC_device_ptr *ptbl = NULL;
+
+	OACC_CHECK_INIT
+	switch(devt) {
+		case acc_device_host:
+			ptbl = OACC_host_devs;
+			n = OACC_nhost_devs;
+			break;
+		case acc_device_default:
+		case acc_device_not_host:
+			ptbl = OACC_acc_devs;
+			n = OACC_nacc_devs;
+			break;
+	}
+
+	LOCK_AQUIRE(OACC_dev_lock);
+	if(ptbl != NULL && n > 0) {
+		for(i = 0 ; i < n; ++i) {
+			OACC_dev_fini(ptbl[i]);
+		}
+	}
+	LOCK_RELEASE(OACC_dev_lock);
+}
+
+void*
+acc_malloc(size_t size)
+{
+	OACC_CHECK_INIT
+	OACC_CHECK_DEV_INIT(OACC_curr_dev[OACC_curr_num])
+	return OACC_alloc_on_device(NULL, size, OACC_curr_dev[OACC_curr_num], 0)->data_ptr;
+}
+
+void
+acc_free(void* ptr)
+{
+	OACC_CHECK_INIT
+	OACC_CHECK_DEV_INIT(OACC_curr_dev[OACC_curr_num])
+	OACC_free_device_mem(ptr, OACC_curr_dev[OACC_curr_num]);
+}
+
+int
+acc_async_test(int cookie)
+{
+	struct OACC_queue_data *q = NULL;
+	OACC_CHECK_INIT
+	q = OACC_find_queue(cookie, NULL);
+	if(q == NULL) {
+		return 1;
+	}
+	return OACC_test_queue(q) == OACC_QS_COMPLETE;
+}
+
+int
+acc_async_test_all()
+{
+	OACC_CHECK_INIT
+	return OACC_test_all_global_queues();
+}
+
+void
+acc_async_wait(int cookie)
+{
+	struct OACC_queue_data *q = NULL, *qprev = NULL;
+	OACC_CHECK_INIT
+	q = OACC_find_queue(cookie, &qprev);
+	if(q != NULL) {
+		OACC_unlink_queue(&OACC_async.named, qprev);
+		OACC_wait_queue(q);
+	}
+}
+
+void
+acc_async_wait_all()
+{
+	OACC_CHECK_INIT
+	OACC_wait_all_global_queues();
+}
+
+int
+acc_on_device(acc_device_t devt)
+{
+	int ret = 0;
+	OACC_CHECK_INIT
+	LOCK_AQUIRE(OACC_dev_lock);
+	ret = OACC_curr_dev == OACC_host_devs;
+	LOCK_RELEASE(OACC_dev_lock);
+	return ret;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/liboacc/openacc.h b/liboacc/openacc.h
new file mode 100755
index 00000000000..94a28722ba9
--- /dev/null
+++ b/liboacc/openacc.h
@@ -0,0 +1,117 @@
+/* 
+This file is part of GCC.
+
+GCC 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 3, or (at your option) any later
+version.
+
+GCC 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 GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+#ifndef OPENACC_H
+#define OPENACC_H
+
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+OpenACC device type
+see OpenACC_1.0 3.1 
+*/
+typedef enum {
+	acc_device_none,
+	acc_device_default,
+	acc_device_host,
+	acc_device_not_host
+} acc_device_t;
+
+/*
+get number of devices of specified type 
+see OpenACC_1.0 3.2.1
+*/
+int acc_get_num_devices(acc_device_t);
+/*
+set device type for next kernels 
+see OpenACC_1.0 3.2.2
+*/
+void acc_set_device_type(acc_device_t);
+/*
+get type of current device
+see OpenACC_1.0 3.2.3
+*/
+acc_device_t acc_get_device_type(void);
+/*
+set current device number
+see OpenACC_1.0 3.2.4
+*/
+void acc_set_device_num(int, acc_device_t);
+/*
+get current device number of specified type
+see OpenACC_1.0 3.2.5
+*/
+int acc_get_device_num(acc_device_t);
+
+/*
+test for async execution
+see OpenACC_1.0 3.2.6
+*/
+int acc_async_test(int);
+/*
+test all async execution
+see OpenACC_1.0 3.2.7
+*/
+int acc_async_test_all(void);
+/*
+wait for async execution
+see OpenACC_1.0 3.2.8
+*/
+void acc_async_wait(int);
+/*
+wait all async execution
+see OpenACC_1.0 3.2.9
+*/
+void acc_async_wait_all(void);
+
+/*
+initialize device
+see OpenACC_1.0 3.2.10
+*/
+void acc_init(acc_device_t);
+/*
+finalize device
+see OpenACC_1.0 3.2.11
+*/
+void acc_shutdown(acc_device_t);
+/*
+execution device
+see OpenACC_1.0 3.2.12
+*/
+int acc_on_device(acc_device_t);
+
+/*
+allocate memory on device
+see OpenACC_1.0 3.2.13
+*/
+void* acc_malloc(size_t);
+/*
+free device memory
+see OpenACC_1.0 3.2.14
+*/
+void acc_free(void*);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif
diff --git a/liboacc/platform.c b/liboacc/platform.c
new file mode 100755
index 00000000000..a81e793a55b
--- /dev/null
+++ b/liboacc/platform.c
@@ -0,0 +1,404 @@
+/* 
+This file is part of GCC.
+
+GCC 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 3, or (at your option) any later
+version.
+
+GCC 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 GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+/* accounting data for OpenCL platforms / devices */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "liboacc-internal.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef WIN32
+#include <malloc.h>
+#define alloca _alloca
+#endif
+
+
+size_t OACC_nplatforms = 0;
+struct OACC_platform_data* OACC_platforms = NULL;
+
+size_t OACC_nhost_devs = 0, OACC_nacc_devs = 0, OACC_curr_num = 0, OACC_host_num = 0, OACC_acc_num = 0;
+OACC_device_ptr *OACC_host_devs = NULL, *OACC_acc_devs = NULL, *OACC_default_dev = NULL, *OACC_curr_dev = NULL;
+
+/* get OpenCL device type */
+static cl_device_type 
+get_device_type(cl_device_id device)
+{
+	cl_int err;
+	cl_device_type type = 0;
+
+	if((err = clGetDeviceInfo(device, CL_DEVICE_TYPE, sizeof(cl_device_type), &type, NULL)) < 0) {
+		OACC_fatal("Can't get device type: %d\n", err);
+	}
+	return type;
+}
+
+/* map OpenCL device type to OpenACC device type */
+static int 
+is_host_device(cl_device_type type)
+{
+	if((type & CL_DEVICE_TYPE_GPU) || (type &  CL_DEVICE_TYPE_ACCELERATOR)) {
+		return 0;
+	}
+	return 1;
+}
+
+static void
+read_environment(OACC_device_ptr** ppdev, size_t* pnum)
+{
+	const char* val = NULL;
+
+	val = getenv("ACC_DEVICE_TYPE");
+	if(val != NULL) {
+		if(strcmp(val, "host") == 0 || strcmp(val, "cpu") == 0) {
+			*ppdev = OACC_host_devs;
+		}
+		else if(strcmp(val, "not_host") == 0 || strcmp(val, "gpu") == 0) {
+			*ppdev = OACC_acc_devs;
+		}
+	}
+
+	val = getenv("ACC_DEVICE_NUM");
+	if(val != NULL) {
+		size_t num = atoi(val);
+		if(num >= 0) {
+			if(*ppdev == OACC_host_devs && num < OACC_nhost_devs) {
+				*pnum = num;
+			}
+			else if(*ppdev == OACC_acc_devs && num < OACC_nacc_devs) {
+				*pnum = num;
+			}
+		}
+	}
+}
+
+/* check if device is available to use */
+static int
+device_usable(cl_device_id device)
+{
+	cl_int err;
+	cl_bool avail;
+	cl_device_exec_capabilities exec_caps;
+
+	/* is device available for OpenCL? */
+	if((err = clGetDeviceInfo(device, CL_DEVICE_AVAILABLE, sizeof(cl_bool), &avail, NULL)) < 0) {
+		OACC_warning("Can't get device availability flag: %d\n", err);
+		return 0;
+	}
+	if(avail != CL_TRUE) {
+		return 0;
+	}
+
+	/* can device execute non native kernels? */
+	if((err = clGetDeviceInfo(device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof(cl_device_exec_capabilities), &exec_caps, NULL)) < 0) {
+		OACC_warning("Can't get device execute capabilities: %d\n", err);
+		return 0;
+	}
+	if((exec_caps & CL_EXEC_KERNEL) == 0) {
+		return 0;
+	}
+
+	/* is compiler available? */
+	if((err = clGetDeviceInfo(device, CL_DEVICE_COMPILER_AVAILABLE, sizeof(cl_bool), &avail, NULL)) < 0) {
+		OACC_warning("Can't get compiler availablity flag: %d\n", err);
+		return 0;
+	}
+	if(avail != CL_TRUE) {
+		return 0;
+	}
+
+	return 1;
+}
+
+/* get various device capabilities */
+static void
+fill_device_caps(OACC_device_ptr dev)
+{
+	cl_int err;
+	cl_bool flag;
+	cl_command_queue_properties qprops;
+
+
+	if((err = clGetDeviceInfo(dev->id, CL_DEVICE_QUEUE_PROPERTIES, sizeof(cl_command_queue_properties), &qprops, NULL)) < 0) {
+		OACC_warning("Can't get device queue properties: %d\n", err);
+	}
+	else {
+		if((qprops & CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE) != 0) {
+			dev->flags |= OACC_DF_OUT_OF_ORDER;
+		}
+		if((qprops & CL_QUEUE_PROFILING_ENABLE) != 0) {
+			dev->flags |= OACC_DEF_PROFILING;
+		}
+	}
+
+	if((err = clGetDeviceInfo(dev->id, CL_DEVICE_HOST_UNIFIED_MEMORY, sizeof(cl_bool), &flag, NULL)) < 0) {
+		OACC_warning("Can't get unified memory flag: %d\n", err);
+	}
+	else {
+		if(flag != CL_FALSE) {
+			dev->flags |= OACC_DF_UNIFIED_MEM;
+		}
+	}
+
+	if((err = clGetDeviceInfo(dev->id, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof(cl_uint), &(dev->max_comp_units), NULL)) < 0) {
+		OACC_warning("Can't get computational units number: %d\n", err);
+	}
+
+	if((err = clGetDeviceInfo(dev->id, CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, sizeof(cl_uint), &(dev->max_wi_dims), NULL)) < 0) {
+		OACC_warning("Can't get maximal workitems dimension: %d\n", err);
+	}
+	else {
+		dev->max_wi_sizes = (size_t*)calloc(dev->max_wi_dims, sizeof(size_t));
+		if(dev->max_wi_sizes == NULL) {
+			OACC_fatal("Can't allocate memory for workitems sizes\n");
+		}
+		if((err = clGetDeviceInfo(dev->id, CL_DEVICE_MAX_WORK_ITEM_SIZES, dev->max_wi_dims * sizeof(size_t), dev->max_wi_sizes, NULL)) < 0) {
+			OACC_warning("Can't get maximal workitems sizes: %d\n", err);
+		}
+	}
+
+	if((err = clGetDeviceInfo(dev->id, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(size_t), &(dev->max_wg_size), NULL)) < 0) {
+		OACC_warning("Can't get maximal workgroup size: %d\n", err);
+	}
+
+	if((err = clGetDeviceInfo(dev->id, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof(cl_ulong), &(dev->max_alloc), NULL)) < 0) {
+		OACC_warning("Can't get maximal allocation size: %d\n", err);
+	}
+
+	if((err = clGetDeviceInfo(dev->id, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(cl_ulong), &(dev->glob_mem_size), NULL)) < 0) {
+		OACC_warning("Can't get global memory size: %d\n", err);
+	}
+
+	if((err = clGetDeviceInfo(dev->id, CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, sizeof(cl_ulong), &(dev->const_mem_size), NULL)) < 0) {
+		OACC_warning("Can't get maximal constant buffer size: %d\n", err);
+	}
+
+	if((err = clGetDeviceInfo(dev->id, CL_DEVICE_LOCAL_MEM_SIZE, sizeof(cl_ulong), &(dev->loc_mem_size), NULL)) < 0) {
+		OACC_warning("Can't get local memory size: %d\n", err);
+	}
+
+	if((err = clGetDeviceInfo(dev->id, CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR, sizeof(cl_uint), &(dev->vec_size[OACC_IDX_CHAR][OACC_IDX_NATIVE]), NULL)) < 0) {
+		OACC_warning("Can't get native vector width for char: %d\n", err);
+	}
+	if((err = clGetDeviceInfo(dev->id, CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR, sizeof(cl_uint), &(dev->vec_size[OACC_IDX_CHAR][OACC_IDX_PREF]), NULL)) < 0) {
+		OACC_warning("Can't get preferred vector width for char: %d\n", err);
+	}
+	if((err = clGetDeviceInfo(dev->id, CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT, sizeof(cl_uint), &(dev->vec_size[OACC_IDX_SHORT][OACC_IDX_NATIVE]), NULL)) < 0) {
+		OACC_warning("Can't get native vector width for short: %d\n", err);
+	}
+	if((err = clGetDeviceInfo(dev->id, CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT, sizeof(cl_uint), &(dev->vec_size[OACC_IDX_SHORT][OACC_IDX_PREF]), NULL)) < 0) {
+		OACC_warning("Can't get preferred vector width for short: %d\n", err);
+	}
+	if((err = clGetDeviceInfo(dev->id, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof(cl_uint), &(dev->vec_size[OACC_IDX_INT][OACC_IDX_NATIVE]), NULL)) < 0) {
+		OACC_warning("Can't get native vector width for int: %d\n", err);
+	}
+	if((err = clGetDeviceInfo(dev->id, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, sizeof(cl_uint), &(dev->vec_size[OACC_IDX_INT][OACC_IDX_PREF]), NULL)) < 0) {
+		OACC_warning("Can't get preferred vector width for int: %d\n", err);
+	}
+	if((err = clGetDeviceInfo(dev->id, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof(cl_uint), &(dev->vec_size[OACC_IDX_LONG][OACC_IDX_NATIVE]), NULL)) < 0) {
+		OACC_warning("Can't get native vector width for long: %d\n", err);
+	}
+	if((err = clGetDeviceInfo(dev->id, CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, sizeof(cl_uint), &(dev->vec_size[OACC_IDX_LONG][OACC_IDX_PREF]), NULL)) < 0) {
+		OACC_warning("Can't get preferred vector width for long: %d\n", err);
+	}
+	if((err = clGetDeviceInfo(dev->id, CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT, sizeof(cl_uint), &(dev->vec_size[OACC_IDX_FLOAT][OACC_IDX_NATIVE]), NULL)) < 0) {
+		OACC_warning("Can't get native vector width for float: %d\n", err);
+	}
+	if((err = clGetDeviceInfo(dev->id, CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT, sizeof(cl_uint), &(dev->vec_size[OACC_IDX_FLOAT][OACC_IDX_PREF]), NULL)) < 0) {
+		OACC_warning("Can't get preferred vector width for float: %d\n", err);
+	}
+	if((err = clGetDeviceInfo(dev->id, CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE, sizeof(cl_uint), &(dev->vec_size[OACC_IDX_DOUBLE][OACC_IDX_NATIVE]), NULL)) < 0) {
+		OACC_warning("Can't get native vector width for double: %d\n", err);
+	}
+	if((err = clGetDeviceInfo(dev->id, CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE, sizeof(cl_uint), &(dev->vec_size[OACC_IDX_DOUBLE][OACC_IDX_PREF]), NULL)) < 0) {
+		OACC_warning("Can't get preferred vector width for double: %d\n", err);
+	}
+	if((err = clGetDeviceInfo(dev->id, CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF, sizeof(cl_uint), &(dev->vec_size[OACC_IDX_HALF][OACC_IDX_NATIVE]), NULL)) < 0) {
+		OACC_warning("Can't get native vector width for half: %d\n", err);
+	}
+	if((err = clGetDeviceInfo(dev->id, CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF, sizeof(cl_uint), &(dev->vec_size[OACC_IDX_HALF][OACC_IDX_PREF]), NULL)) < 0) {
+		OACC_warning("Can't get preferred vector width for half: %d\n", err);
+	}
+
+}
+
+/* global platforms array initialization */
+void 
+OACC_env_init(void)
+{
+	cl_uint np = 0, i;
+	cl_int err;
+	cl_platform_id* pids;
+	size_t hidx = 0, aidx = 0;
+
+	LOCK_AQUIRE(OACC_dev_lock);
+
+	if(OACC_platforms != NULL) {
+		LOCK_RELEASE(OACC_dev_lock);
+		return;
+	}
+
+	/* make cleanup implicit */
+	atexit(OACC_env_fini);
+	if((err = clGetPlatformIDs(0, NULL, &np)) < 0 || np == 0) {
+		OACC_fatal("OpenCL platforms are not found: %d\n", err);
+	}
+
+	pids = (cl_platform_id*)alloca(sizeof(cl_platform_id) *np);
+	if((err = clGetPlatformIDs(np, pids, NULL)) < 0) {
+		OACC_fatal("Can't get platform IDs: %d\n", err);
+	}
+
+	OACC_nplatforms = np;
+	OACC_platforms = (struct OACC_platform_data*)calloc(OACC_nplatforms, sizeof(struct OACC_platform_data));
+	if(OACC_platforms == NULL) {
+		OACC_fatal("Not enough memory for platforms info\n");
+	}
+
+	for(i = 0; i < OACC_nplatforms; ++i) {
+		cl_uint nd, j;
+		cl_device_id* dids;
+
+		/* get array of devices in this platform */
+		OACC_platforms[i].id = pids[i];
+		if((err = clGetDeviceIDs(pids[i], CL_DEVICE_TYPE_ALL, 0, NULL, &nd)) < 0 || nd == 0) {
+			OACC_platforms[i].ndevs = 0;
+			OACC_fatal("Can't get devices for platform: %d\n", err);
+		}
+		OACC_platforms[i].ndevs = nd;
+		dids = (cl_device_id*)alloca(sizeof(cl_device_id) * OACC_platforms[i].ndevs);
+		clGetDeviceIDs(pids[i], CL_DEVICE_TYPE_ALL, nd, dids, NULL);
+		OACC_platforms[i].devs = (struct OACC_device_data*)calloc(OACC_platforms[i].ndevs, sizeof(struct OACC_device_data));
+		if(OACC_platforms[i].devs == NULL) {
+			OACC_fatal("Not enough memory for device info\n");
+		}
+
+		/* initialize per devcie data, NOTE: context and command queue are initialized later in OACC_dev_ini function */
+		for(j = 0; j < OACC_platforms[i].ndevs; ++j) {
+			cl_device_type type;
+
+			if(!device_usable(dids[j])) {
+				OACC_platforms[i].devs[j].id = 0;
+				continue;
+			}
+
+			OACC_platforms[i].devs[j].id = dids[j];
+			type = get_device_type(dids[j]);
+			OACC_platforms[i].devs[j].type = type;
+			LOCK_INIT(OACC_platforms[i].devs[j].dev_lock);
+
+			/* cache device info */
+			fill_device_caps(&OACC_platforms[i].devs[j]);
+
+			/* count OpenACC devices per type */
+			(is_host_device(type)) ? ++OACC_nhost_devs : ++OACC_nacc_devs;
+		}
+
+	}
+
+	if(OACC_nacc_devs == 0 && OACC_nhost_devs == 0) {
+		OACC_fatal("No OpenCL device found\n");
+	}
+
+	/*
+	create arrays of pointers to map OpenACC host / not devices to OpenCL devices
+	*/
+
+	if(OACC_nhost_devs > 0) {
+		OACC_host_devs = (OACC_device_ptr*)calloc(OACC_nhost_devs, sizeof(OACC_device_ptr));
+		if(OACC_host_devs == NULL) {
+			OACC_fatal("Not enough memory for host device table\n");
+		}
+	}
+	if(OACC_nacc_devs > 0) {
+		OACC_acc_devs = (OACC_device_ptr*)calloc(OACC_nacc_devs, sizeof(OACC_device_ptr));
+		if(OACC_acc_devs == NULL) {
+			OACC_fatal("Not enough memory for accelerator device table\n");
+		}
+	}
+
+	for(i = 0; i < OACC_nplatforms; ++i) {
+		size_t j;
+
+		for(j = 0; j < OACC_platforms[i].ndevs; ++j) {
+			if(is_host_device(OACC_platforms[i].devs[j].type)) {
+				OACC_host_devs[hidx++] = OACC_platforms[i].devs + j;
+			}
+			else {
+				OACC_acc_devs[aidx++] = OACC_platforms[i].devs + j;
+			}
+		}
+	}
+
+	OACC_curr_dev = OACC_default_dev = (OACC_nacc_devs > 0) ? OACC_acc_devs : OACC_host_devs;
+	OACC_acc_num = OACC_host_num = OACC_curr_num = 0;
+
+	read_environment(&OACC_curr_dev, &OACC_curr_num);
+
+	LOCK_RELEASE(OACC_dev_lock);
+}
+
+void
+OACC_env_fini(void)
+{
+	size_t i, j;
+
+	LOCK_AQUIRE(OACC_dev_lock);
+
+	if(OACC_nplatforms == 0) {
+		LOCK_RELEASE(OACC_dev_lock);
+		return;
+	}
+
+	/* free arrays of pointers mapping */
+	if(OACC_nhost_devs > 0) {
+		free(OACC_host_devs);
+	}
+	if(OACC_nacc_devs > 0) {
+		free(OACC_acc_devs);
+	}
+
+	/* per platform cleanup*/
+	for(i = 0; i < OACC_nplatforms; ++i) {
+		
+		/* per device cleanup*/
+		if(OACC_platforms[i].ndevs > 0) {
+			struct OACC_device_data* pdev = OACC_platforms[i].devs;
+			for(j = 0; j < OACC_platforms[i].ndevs; ++j, ++pdev) {
+				OACC_dev_fini(pdev);
+				free(pdev->max_wi_sizes);
+				LOCK_DESTROY(pdev->dev_lock);
+			}
+			free(OACC_platforms[i].devs);
+		}
+	}
+	
+	free(OACC_platforms);
+	LOCK_RELEASE(OACC_dev_lock);
+
+	LOCK_DESTROY(OACC_dev_lock);
+	LOCK_DESTROY(OACC_async_lock);
+	LOCK_DESTROY(OACC_profile_lock);
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/liboacc/program.c b/liboacc/program.c
new file mode 100755
index 00000000000..f598b50ed07
--- /dev/null
+++ b/liboacc/program.c
@@ -0,0 +1,196 @@
+/* 
+This file is part of GCC.
+
+GCC 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 3, or (at your option) any later
+version.
+
+GCC 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 GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+/* procedures dealing with OpenCL programs/kernels */
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "liboacc-internal.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef WIN32
+#include <malloc.h>
+#define alloca _alloca
+#endif
+ /* read source for PROG_NAME form file and returns allocated buffer
+ (CALLER must FREE) and size of program
+*/
+static char*
+OACC_get_prog_source(const char* prog_name, size_t* psize)
+{
+	FILE *fp = NULL;
+	char* buf = NULL;
+	size_t size;
+
+	if((fp = fopen(prog_name, "r")) == NULL) {
+		OACC_fatal("Can't open file '%s'\n", prog_name);
+		return NULL;
+	}
+	fseek(fp, 0, SEEK_END);
+	size = ftell(fp);
+	rewind(fp);
+
+	buf = (char*)malloc(size + 1);
+	if(buf == NULL) {
+		OACC_fatal("Not enough memory for %d bytes buffer\n", size+1);
+		fclose(fp);
+		return NULL;
+	}
+	fread(buf, sizeof(char), size, fp);
+	buf[size] = '\0';
+	fclose(fp);
+
+	if(psize != NULL) {
+		*psize = size;
+	}
+	return buf;
+}
+
+/* initialize program object in given context: get source, create OpenCL object, build*/
+static struct OACC_program_data*
+OACC_load_prog(const char* prog_name, cl_context ctx)
+{
+	char* src = NULL;
+	struct OACC_program_data* prog = NULL;
+	cl_int err;
+	size_t size = 0;
+
+	src = OACC_get_prog_source(prog_name, &size);
+	if(src == NULL) {
+		return NULL;
+	}
+
+	prog = (struct OACC_program_data*)calloc(1, sizeof(struct OACC_program_data));
+	prog->prog = clCreateProgramWithSource(ctx, 1, (const char**)&src, &size, &err);
+	if(err < 0) {
+		OACC_fatal("Can't create program: %d\n", err);
+		free(prog);
+		free(src);
+		return NULL;
+	}
+
+	err = clBuildProgram(prog->prog, 0, NULL, NULL, NULL, NULL);
+	if(err < 0) {
+		char* the_log = NULL;
+		clGetProgramBuildInfo(prog->prog, OACC_curr_dev[OACC_curr_num]->id, CL_PROGRAM_BUILD_LOG, 0, NULL, &size);
+		the_log = (char*)malloc(size + 1);
+		clGetProgramBuildInfo(prog->prog, OACC_curr_dev[OACC_curr_num]->id, CL_PROGRAM_BUILD_LOG, size+1, the_log, NULL);
+		the_log[size] = '\0';
+		OACC_fatal("Error building program: %d\n%s\n", err, the_log);
+	}
+
+	free(src);
+	prog->name = strdup(prog_name);
+
+	return prog;
+}
+
+/* find desired program with name PROG_NAME in given context */
+static struct OACC_program_data*
+OACC_get_program(const char* prog_name, struct OACC_device_data* pdev)
+{
+	struct OACC_program_data *prog = NULL;
+
+	for(prog = pdev->prog_head; prog != NULL; prog = prog->next) {
+		if(strcmp(prog_name, prog->name) == 0) {
+			return prog;
+		}
+	}
+
+	LOCK_AQUIRE(pdev->dev_lock);
+	prog = OACC_load_prog(prog_name, pdev->ctx);
+	if(prog != NULL) {
+		prog->next = pdev->prog_head;
+		pdev->prog_head = prog;
+	}
+	LOCK_RELEASE(pdev->dev_lock);
+	return prog;
+}
+
+/* initialize kernel data: create, allocated space for arguments */
+static struct OACC_kernel_data*
+OACC_load_kernel(struct OACC_program_data* prog, const char* kern_name)
+{
+	cl_int err;
+	struct OACC_kernel_data* kern = NULL;
+
+	kern = (struct OACC_kernel_data*)calloc(1, sizeof(struct OACC_kernel_data));
+	if(kern == NULL) {
+		OACC_fatal("Not enough memory for kernels\n");
+	}
+	kern->kern = clCreateKernel(prog->prog, kern_name, &err);
+	if(err < 0) {
+		OACC_fatal("Can't create kernel: %d\n", err);
+	}
+
+	kern->name = strdup(kern_name);
+	err = clGetKernelInfo(kern->kern, CL_KERNEL_NUM_ARGS, sizeof(size_t), &kern->nargs, NULL);
+	if(err < 0) {
+		OACC_fatal("Can't get # of kernel args: %d\n", err);
+	}
+	kern->args = (OACC_buffer_ptr*)calloc(kern->nargs, sizeof(OACC_buffer_ptr));
+	if(kern->args == NULL) {
+		OACC_fatal("Not enough memory for kernel arguments\n");
+	}
+	return kern;
+}
+/* find or load kernel */
+static struct OACC_kernel_data*
+OACC_get_kernel(struct OACC_program_data* prog, const char* kern_name, OACC_device_ptr pdev)
+{
+	struct OACC_kernel_data* kern = NULL;
+
+	for(kern = prog->kern_head; kern != NULL; kern = kern->next) {
+		if(strcmp(kern->name, kern_name) == 0) {
+			return kern;
+		}
+	}
+
+	LOCK_AQUIRE(pdev->dev_lock);
+	kern = OACC_load_kernel(prog, kern_name);
+	if(kern != NULL) {
+		kern->next = prog->kern_head;
+		prog->kern_head = kern;
+	}
+	LOCK_RELEASE(pdev->dev_lock);
+	return kern;
+}
+
+/* get kernel KERN_NAME from program PROG_NAME */
+struct OACC_kernel_data*
+OACC_find_kernel(const char* prog_name, const char* kern_name)
+{
+	struct OACC_program_data *prog = NULL;
+	OACC_device_ptr dev_ptr;
+
+	if(OACC_curr_dev == NULL) {
+		return NULL;
+	}
+	dev_ptr = OACC_curr_dev[OACC_curr_num];
+	prog = OACC_get_program(prog_name, dev_ptr);
+	if(prog == NULL) {
+		return NULL;
+	}
+	return OACC_get_kernel(prog, kern_name, dev_ptr);
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/liboacc/runtime.c b/liboacc/runtime.c
new file mode 100755
index 00000000000..1716d1b024b
--- /dev/null
+++ b/liboacc/runtime.c
@@ -0,0 +1,156 @@
+/* 
+This file is part of GCC.
+
+GCC 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 3, or (at your option) any later
+version.
+
+GCC 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 GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+/* runtime support for OpenACC */
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include "liboacc-internal.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* per device init */
+void
+OACC_dev_init(OACC_device_ptr pdev)
+{
+	cl_int err;
+ 	cl_command_queue_properties queue_props = 0;
+
+	LOCK_AQUIRE(pdev->dev_lock);
+	if(pdev->ctx != NULL && pdev->queue != NULL) {
+		LOCK_RELEASE(pdev->dev_lock);
+		return;
+	}
+	if(pdev->ctx == NULL) {
+		pdev->ctx = clCreateContext(NULL, 1, &pdev->id, NULL, NULL, &err);
+		if(err < 0) {
+			OACC_fatal("can't create context: %d\n", err);
+		}
+	}
+	if(pdev->queue == NULL) {
+		if((pdev->flags & OACC_DF_OUT_OF_ORDER) != 0) {
+			queue_props |= CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE;
+		}
+		if(OACC_profiling != 0 && (pdev->flags & OACC_DEF_PROFILING) != 0) {
+			queue_props |= CL_QUEUE_PROFILING_ENABLE;
+		}
+		pdev->queue = clCreateCommandQueue(pdev->ctx, pdev->id, queue_props, &err);
+		if(err < 0) {
+			OACC_fatal("Can't create command queue: %d\n", err);
+		}
+	}
+	LOCK_RELEASE(pdev->dev_lock);
+}
+
+/* per device cleanup */
+void
+OACC_dev_fini(OACC_device_ptr pdev)
+{
+	struct OACC_program_data *prog, *pprog;
+	struct OACC_kernel_data *kern, *pkern;
+	OACC_buffer_ptr buf, pbuf;
+
+	LOCK_AQUIRE(pdev->dev_lock);
+
+	pprog = pdev->prog_head;
+	while(pprog != NULL) {
+		prog = pprog;
+		pprog = prog->next;
+
+		free(prog->name);
+
+		pkern = prog->kern_head;
+		while(pkern != NULL) {
+			kern = pkern;
+			pkern = kern->next;
+
+			free(kern->name);
+			free(kern->args);
+			clReleaseKernel(kern->kern);
+			free(kern);
+		}
+		clReleaseProgram(prog->prog);
+		free(prog);
+	}
+
+	pbuf = pdev->mem;
+	while(pbuf != NULL) {
+		buf = pbuf;
+		pbuf = pbuf->next;
+
+		if(buf->data_ptr != NULL) {
+			clEnqueueUnmapMemObject(pdev->queue, buf->mem_obj, buf->data_ptr, 0, NULL, NULL);
+		}
+		clReleaseMemObject(buf->mem_obj);
+		free(buf);
+	}
+
+	if(pdev->queue != NULL) {
+		clReleaseCommandQueue(pdev->queue);
+		pdev->queue = NULL;
+	}
+	if(pdev->ctx != NULL) {
+		clReleaseContext(pdev->ctx);
+		pdev->ctx = NULL;
+	}
+	LOCK_RELEASE(pdev->dev_lock);
+}
+
+/* enqueue kernel object */
+void
+OACC_enqueue_kernel(struct OACC_kernel_data* kern, unsigned worksize, struct OACC_queue_data* queue, unsigned idx)
+{
+	cl_int err;
+	cl_uint nev;
+	cl_event *ev_wait = NULL, *ev_set = NULL;
+
+	OACC_EQ_EVENTS(queue, nev, ev_wait, ev_set, idx)
+
+	err = clEnqueueNDRangeKernel(OACC_curr_dev[OACC_curr_num]->queue, kern->kern, 1 ,NULL, &worksize, NULL, nev, ev_wait, ev_set);
+	if(err < 0) {
+		OACC_fatal("Can't enqueue kernel: %d\n", err);
+	}
+}
+
+
+/* fatal error reporter */
+void
+OACC_fatal(const char* msg, ...)
+{
+	va_list args;
+
+	va_start(args, msg);
+	vfprintf(stderr, msg, args);
+	va_end(args);
+	abort();
+}
+
+void
+OACC_warning(const char* msg, ...)
+{
+	va_list args;
+
+	va_start(args, msg);
+	vfprintf(stderr, msg, args);
+	va_end(args);
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/liboacc/synchro.c b/liboacc/synchro.c
new file mode 100755
index 00000000000..ba229d087e5
--- /dev/null
+++ b/liboacc/synchro.c
@@ -0,0 +1,414 @@
+/* 
+This file is part of GCC.
+
+GCC 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 3, or (at your option) any later
+version.
+
+GCC 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 GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+/* synchronization for OpenACC */
+#include <stdlib.h>
+#include <stdio.h>
+#include "liboacc-internal.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct OACC_async_data OACC_async;
+
+int OACC_profiling = 0;
+long long OACC_read_time = 0LL, OACC_write_time = 0LL, OACC_exec_time = 0LL;
+
+/* attach event descriptor EV in the end of QUEUE */
+static void
+OACC_link_event(struct OACC_queue_data* queue, OACC_event_ptr ev)
+{
+	LOCK_AQUIRE(queue->queue_lock);
+	if(queue->head == NULL) {
+		queue->head = queue->tail = queue->curr = ev;
+	}
+	else {
+		ev->prev = queue->tail;
+		queue->tail->next = ev;
+		queue->tail = ev;
+	}
+	LOCK_RELEASE(queue->queue_lock);
+}
+
+/* create new synchronization queue,
+source filename and line number are remembered for the sake of profiling
+*/
+struct OACC_queue_data*
+OACC_create_queue(const char* src, int lineno)
+{
+	struct OACC_queue_data *queue = NULL;
+
+	queue = (struct OACC_queue_data*)calloc(1, sizeof(struct OACC_queue_data));
+	if(queue == NULL) {
+		OACC_fatal("Not enough memory for event queue\n");
+	}
+	queue->source_file = src;
+	queue->source_line = lineno;
+	LOCK_INIT(queue->queue_lock);
+
+	return queue;
+}
+
+/* add OpenCL event array of kind KIND (see OACC_PF_* in liboacc-internel.h) */
+void
+OACC_add_event(struct OACC_queue_data* queue, unsigned n, int kind)
+{
+	OACC_event_ptr pev = NULL;
+
+	pev = (OACC_event_ptr)calloc(1, sizeof(struct OACC_event_data));
+	pev->kind = kind;
+	pev->nevents = n;
+	pev->events = (cl_event*)calloc(n, sizeof(cl_event));
+
+	OACC_link_event(queue, pev);
+}
+
+/* wait enqueued events finish, print profiling data if desired */
+void
+OACC_wait_queue(struct OACC_queue_data* queue)
+{
+	cl_int err;
+	OACC_event_ptr ev, prev;
+
+	if(queue == NULL || queue->tail == NULL) {
+		return;
+	}
+
+	LOCK_AQUIRE(queue->queue_lock);
+	err = clWaitForEvents(queue->tail->nevents, queue->tail->events);
+	if(err < 0) {
+		OACC_fatal("Can't wait for events: %d\n", err);
+	}
+
+	if(OACC_profiling) {
+
+
+		for(ev = queue->head; ev != NULL; ev = ev->next) {
+			unsigned i;
+			cl_ulong min_start, max_finish;
+
+			min_start = ~0; max_finish = 0;
+			for(i = 0; i < ev->nevents; ++i) {
+				cl_ulong start, finish;
+				cl_ulong submited;
+
+				err = clGetEventProfilingInfo(ev->events[i], CL_PROFILING_COMMAND_SUBMIT, sizeof(cl_ulong), &submited, NULL);
+				if(err < 0) {
+					if(err == CL_PROFILING_INFO_NOT_AVAILABLE) {
+						OACC_warning("Profiling: submit info is not available\n");
+						submited = 0;
+					}
+					else {
+						OACC_fatal("Can't get submit profiling: %d\n", err);
+					}
+				}
+
+				err = clGetEventProfilingInfo(ev->events[i], CL_PROFILING_COMMAND_START, sizeof(cl_ulong), &start, NULL);
+				if(err < 0) {
+					if(err == CL_PROFILING_INFO_NOT_AVAILABLE) {
+						OACC_warning("Profiling: start info is not available\n");
+						start = 0;
+					}
+					else {
+						OACC_fatal("Can't get start profiling: %d\n", err);
+					}
+				}
+#ifdef MEASURE_START
+				if(start < min_start) {
+					min_start = start;
+				}
+#else
+				if(submited < min_start) {
+					min_start = submited;
+				}
+#endif
+				err = clGetEventProfilingInfo(ev->events[i], CL_PROFILING_COMMAND_END, sizeof(cl_ulong), &finish, NULL);
+				if(err < 0) {
+					if(err == CL_PROFILING_INFO_NOT_AVAILABLE) {
+						OACC_warning("Profiling: finish info is not available\n");
+						finish = 0;
+					}
+					else {
+						OACC_fatal("Can't get finish profiling: %d\n", err);
+					}
+				}
+				if(finish > max_finish) {
+					max_finish = finish;
+				}
+			}
+
+			LOCK_AQUIRE(OACC_profile_lock);
+			switch(ev->kind) {
+			case OACC_PF_DATAIN:
+				OACC_write_time += max_finish - min_start;
+				break;
+			case OACC_PF_EXEC:
+				OACC_exec_time += max_finish - min_start;
+				break;
+			case OACC_PF_DATAOUT:
+				OACC_read_time += max_finish - min_start;
+				break;
+			}
+			LOCK_RELEASE(OACC_profile_lock);
+		}
+
+		LOCK_AQUIRE(OACC_profile_lock);
+		printf("Profile for region in %s:%d data to device = %lld, data from device = %lld, execute = %lld\n", 
+			queue->source_file, queue->source_line, OACC_write_time, OACC_read_time, OACC_exec_time);
+		LOCK_RELEASE(OACC_profile_lock);
+	}
+
+	prev = queue->head;
+	while(prev != NULL) {
+		ev = prev;
+		prev = prev->next;
+
+		free(ev->events);
+		free(ev);
+	}
+	LOCK_RELEASE(queue->queue_lock);
+	LOCK_DESTROY(queue->queue_lock);
+	free(queue);
+
+}
+
+/* simulate OpenCL events complete in the case we bypass it */
+void
+OACC_fire_event(struct OACC_queue_data* queue, unsigned idx, OACC_device_ptr dev_ptr)
+{
+	cl_int err;
+	cl_uint nev;
+	cl_event *ev_wait = NULL, *ev_set = NULL;
+
+	LOCK_AQUIRE(queue->queue_lock);
+	OACC_EQ_EVENTS(queue, nev, ev_wait, ev_set, idx)
+
+	if(nev > 0 && ev_wait != NULL) {
+		if((err = clWaitForEvents(nev, ev_wait)) < 0) {
+			OACC_fatal("Can't wait for events: %d\n", err);
+		}
+	}
+
+	if(ev_set != NULL) {
+		*ev_set = clCreateUserEvent(dev_ptr->ctx, &err);
+		if(err < 0) {
+			OACC_fatal("Can't create user event: %d\n", err);
+		}
+		err = clSetUserEventStatus(*ev_set, CL_COMPLETE);
+		if(err < 0) {
+			OACC_fatal("Can't fire user event: %d\n", err);
+		}
+	}
+	LOCK_RELEASE(queue->queue_lock);
+}
+
+/* attach queue to list */
+static void
+OACC_link_queue_list(struct OACC_queue_data** plist, struct OACC_queue_data* queue)
+{
+	LOCK_AQUIRE(OACC_async_lock);
+	queue->next = *plist;
+	*plist = queue;
+	LOCK_RELEASE(OACC_async_lock);
+}
+
+/* find queue with specified integer name */
+struct OACC_queue_data*
+OACC_find_queue(int cookie, struct OACC_queue_data** pprev)
+{
+	struct OACC_queue_data *q = NULL, *qprev = NULL;
+
+	LOCK_AQUIRE(OACC_async_lock);
+	for(qprev = q = OACC_async.named; q != NULL; qprev = q, q = q->next) {
+		if(q->cookie == cookie) {
+			if(pprev != NULL) {
+				*pprev = qprev;
+			}
+			break;
+		}
+	}
+	LOCK_RELEASE(OACC_async_lock);
+	return q;
+}
+
+struct OACC_queue_data*
+OACC_unlink_queue(struct OACC_queue_data** plist, struct OACC_queue_data* prev)
+{
+	struct OACC_queue_data* queue = NULL;
+
+	if(prev == NULL) {
+		return NULL;
+	}
+
+	LOCK_AQUIRE(OACC_async_lock);
+	queue = prev->next;
+	if(prev == *plist) {
+		*plist = queue->next;
+	}
+	else {
+		prev->next = queue->next;
+	}
+	LOCK_RELEASE(OACC_async_lock);
+	return queue;
+}
+
+/* attach one queue in the end of the other */
+static void
+OACC_merge_queues(struct OACC_queue_data* dst, struct OACC_queue_data* src)
+{
+	OACC_event_ptr ev;
+
+	LOCK_AQUIRE(src->queue_lock);
+	for(ev = src->head; ev != NULL; ev = ev->next) {
+		OACC_link_event(dst, ev);
+	}
+	LOCK_RELEASE(src->queue_lock);
+}
+
+/* add queue with given name */
+void
+OACC_add_queue_with_name(struct OACC_queue_data* queue, int name)
+{
+	struct OACC_queue_data* q = OACC_find_queue(name, NULL);
+
+	if(q != NULL) {
+		OACC_merge_queues(q, queue);
+		free(queue);
+	}
+	else {
+		OACC_link_queue_list(&OACC_async.named, queue);
+	}
+}
+
+/* add nameless queue */
+void
+OACC_add_queue_without_name(struct OACC_queue_data* queue)
+{
+	OACC_link_queue_list(&OACC_async.nameless, queue);
+}
+
+/* count still running queues */
+static int
+OACC_count_unfinished(struct OACC_queue_data** list, struct OACC_queue_data **pwait_list)
+{
+	int count = 0;
+	struct OACC_queue_data *q = NULL, *qprev = NULL;
+
+	for(qprev = q = *list; q != NULL; qprev = q, q = q->next) {
+		switch(OACC_test_queue(q)) {
+		case OACC_QS_RUNNING:
+			++count;
+			break;
+		case OACC_QS_READY:
+			++count;
+			if(pwait_list != NULL) {
+				OACC_unlink_queue(list, qprev);
+				OACC_link_queue_list(pwait_list, q);
+			}
+			break;
+		}
+	}
+	return count;
+}
+
+/* wait all globally visible queues */
+void
+OACC_wait_all_global_queues()
+{
+	int unfinished;
+
+	do {
+		struct OACC_queue_data *wait_list = NULL;
+		unfinished = 0;
+
+		unfinished += OACC_count_unfinished(&OACC_async.named, &wait_list);
+		unfinished += OACC_count_unfinished(&OACC_async.nameless, &wait_list);
+
+		if(wait_list != NULL) {
+			struct OACC_queue_data *q = wait_list, *qnext = NULL;
+			while(q != NULL) {
+				qnext = q->next;
+				OACC_wait_queue(q);
+				q = qnext;
+			}
+		}
+
+	} while(unfinished > 0);
+
+}
+
+/* check queue status */
+enum OACC_queue_status
+OACC_test_queue(struct OACC_queue_data* queue)
+{
+	cl_uint i;
+
+	LOCK_AQUIRE(queue->queue_lock);
+
+	if(queue->curr != queue->tail) {
+		LOCK_RELEASE(queue->queue_lock);
+		return OACC_QS_RUNNING;
+	}
+
+	for(i = 0; i < queue->tail->nevents; ++i) {
+		if(queue->tail->events[i] == (void*)0) {
+			LOCK_RELEASE(queue->queue_lock);
+			return OACC_QS_RUNNING;
+		}
+	}
+
+	for(i = 0; i < queue->tail->nevents; ++i) {
+			cl_int err, status;
+
+			err = clGetEventInfo(queue->tail->events[i], CL_EVENT_COMMAND_EXECUTION_STATUS, sizeof(cl_int), &status, NULL);
+			if(err < 0) {
+				OACC_fatal("Can't get event status: %s\n", err);
+			}
+			if(status > CL_COMPLETE) {
+				LOCK_RELEASE(queue->queue_lock);
+				return OACC_QS_READY;
+			}
+	}
+
+	LOCK_RELEASE(queue->queue_lock);
+	return OACC_QS_COMPLETE;
+}
+
+/* check all globally visible queues */
+int
+OACC_test_all_global_queues(void)
+{
+	int unfinished = 0;
+
+	unfinished += OACC_count_unfinished(&OACC_async.named, NULL);
+	unfinished += OACC_count_unfinished(&OACC_async.nameless, NULL);
+	return unfinished == 0;
+}
+
+/* enable profiling */
+void
+OACC_profiling_enable(void)
+{
+	LOCK_AQUIRE(OACC_profile_lock);
+	OACC_profiling = 1;
+	OACC_read_time = 0LL, OACC_write_time = 0LL, OACC_exec_time = 0LL;
+	LOCK_RELEASE(OACC_profile_lock);
+}
+
+#ifdef __cplusplus
+}
+#endif