diff --git a/gcc/ChangeLog.cilk b/gcc/ChangeLog.cilk
index 8d65ca2..11eca8e 100644
--- a/gcc/ChangeLog.cilk
+++ b/gcc/ChangeLog.cilk
@@ -1,4 +1,11 @@
-2011-01-16  Balaji V. Iyer  <balaji.v.iyer@intel.com>
+2012-01-20  Balaji V. Iyer  <balaji.v.iyer@intel.com>
+
+	* Makefile.in: Added array-notation-common.c file for compilation.
+	* array-notation-common.c (mark_cold): New function.
+	(array_notation_init_builtins): Likewise.
+	* tree.h: Added a new enum list called "array_notation_reduce_type."
+	
+2012-01-16  Balaji V. Iyer  <balaji.v.iyer@intel.com>
 
 	* cilk.c (cilk_remove_annotated_functions): Added a int cast for
 	VEC_length in for-loop condition.
diff --git a/gcc/Makefile.in b/gcc/Makefile.in
index 9732ffc..76d2bc0 100644
--- a/gcc/Makefile.in
+++ b/gcc/Makefile.in
@@ -1452,6 +1452,7 @@ OBJS = \
 	xcoffout.o \
         cilk.o \
         cilk-low.o \
+	array-notation-common.o \
 	$(out_object_file) \
 	$(EXTRA_OBJS) \
 	$(host_hook_obj)
@@ -3437,6 +3438,8 @@ lower-subreg.o : lower-subreg.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
 
 
 
+array-notation-common.o: array-notation-common.c $(CONFIG_H) $(SYSTEM_H) \
+    $(TREE_H) $(RTL_H) $(OPTABS_H) $(GIMPLE_H) $(RECOG_H) 
 
 cilk.o: cilk.c $(CONFIG_H) $(SYSTEM_H) $(TREE_H) $(RTL_H) $(OPTABS_H) \
    $(GIMPLE_H) $(RECOG_H) cilk.h
diff --git a/gcc/array-notation-common.c b/gcc/array-notation-common.c
new file mode 100644
index 0000000..059adc4
--- /dev/null
+++ b/gcc/array-notation-common.c
@@ -0,0 +1,101 @@
+/* This file is part of the Intel(R) Cilk(TM) Plus support
+   This file contains the builtin functions for Array
+   notations.
+   Copyright (C) 2012  Free Software Foundation, Inc.
+   Contributed by Balaji V. Iyer <balaji.v.iyer@intel.com>,
+                  Intel Corporation
+
+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 "tree.h"
+#include "langhooks.h"
+#include "expr.h"
+#include "optabs.h" /* for sync_lock_release in detach */
+#include "recog.h"
+#include "cilk.h"
+#include "gimple.h"
+#include "tree-iterator.h"
+#include "c-family/c-common.h"
+#include "toplev.h" /* only correct declaration of warning() */
+#include "output.h"
+#include "dwarf2out.h"
+
+static void
+mark_cold (tree fndecl)
+{
+  DECL_ATTRIBUTES (fndecl) = tree_cons (get_identifier ("cold"), NULL_TREE,
+					DECL_ATTRIBUTES (fndecl));
+}
+
+void
+array_notation_init_builtins (void)
+{
+  tree func_type = NULL_TREE;
+  tree new_func = NULL_TREE;
+  func_type = build_function_type_list (integer_type_node, ptr_type_node,
+					NULL_TREE);
+  new_func = build_fn_decl ("__sec_reduce_add", func_type);
+  mark_cold (new_func);
+  new_func = lang_hooks.decls.pushdecl (new_func);
+
+  func_type = build_function_type_list (integer_type_node, ptr_type_node,
+					NULL_TREE);
+  new_func = build_fn_decl ("__sec_reduce_mul", func_type);
+  mark_cold (new_func);
+  new_func = lang_hooks.decls.pushdecl (new_func);
+
+  func_type = build_function_type_list (integer_type_node, ptr_type_node,
+					NULL_TREE);
+  new_func = build_fn_decl ("__sec_reduce_all_zeros", func_type);
+  mark_cold (new_func);
+  new_func = lang_hooks.decls.pushdecl (new_func);
+
+  func_type = build_function_type_list (integer_type_node, ptr_type_node,
+					NULL_TREE);
+  new_func = build_fn_decl ("__sec_reduce_any_zeros", func_type);
+  mark_cold (new_func);
+  new_func = lang_hooks.decls.pushdecl (new_func);
+
+  func_type = build_function_type_list (integer_type_node, ptr_type_node,
+					NULL_TREE);
+  new_func = build_fn_decl ("__sec_reduce_max", func_type);
+  mark_cold (new_func);
+  new_func = lang_hooks.decls.pushdecl (new_func);
+  
+  func_type = build_function_type_list (integer_type_node, ptr_type_node,
+					NULL_TREE);
+  new_func = build_fn_decl ("__sec_reduce_min", func_type);
+  mark_cold (new_func);
+  new_func = lang_hooks.decls.pushdecl (new_func);
+
+  func_type = build_function_type_list (integer_type_node, ptr_type_node,
+					NULL_TREE);
+  new_func = build_fn_decl ("__sec_reduce_min_ind", func_type);
+  mark_cold (new_func);
+  new_func = lang_hooks.decls.pushdecl (new_func);
+
+  func_type = build_function_type_list (integer_type_node, ptr_type_node,
+					NULL_TREE);
+  new_func = build_fn_decl ("__sec_reduce_max_ind", func_type);
+  mark_cold (new_func);
+  new_func = lang_hooks.decls.pushdecl (new_func);
+  return;
+}
diff --git a/gcc/c-family/ChangeLog.cilk b/gcc/c-family/ChangeLog.cilk
index 5e57983..a4049d0 100644
--- a/gcc/c-family/ChangeLog.cilk
+++ b/gcc/c-family/ChangeLog.cilk
@@ -1,3 +1,8 @@
+2012-01-20  Balaji V. Iyer  <balaji.v.iyer@intel.com>
+
+	* c-common.c (c_define_builtins): Added a call to
+	array_notation_init_builtins function.
+
 2011-12-09  Balaji V. Iyer  <balaji.v.iyer@intel.com>
 
 	* c-common.h: Added build_array_notation_expr prototype.
diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c
index 708b40c..15145a5 100644
--- a/gcc/c-family/c-common.c
+++ b/gcc/c-family/c-common.c
@@ -49,7 +49,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "libfuncs.h"
 #include "cilk.h"
 
-
+extern void array_notation_init_builtins (void);
 enum expand_modifier {EXPAND_NORMAL = 0, EXPAND_STACK_PARM, EXPAND_SUM,
                       EXPAND_CONST_ADDRESS, EXPAND_INITIALIZER, EXPAND_WRITE,
                       EXPAND_MEMORY};
@@ -4660,7 +4660,10 @@ c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
   /* this function will initialize all the builtin functions required by
    * the cilkplus port */
   if (flag_enable_cilk)
-    cilk_init_builtins();
+    {
+      cilk_init_builtins ();
+      array_notation_init_builtins ();
+    }
 
   targetm.init_builtins ();
 
diff --git a/gcc/cp/ChangeLog.cilk b/gcc/cp/ChangeLog.cilk
index 072a6de..ce50e89 100644
--- a/gcc/cp/ChangeLog.cilk
+++ b/gcc/cp/ChangeLog.cilk
@@ -1,3 +1,25 @@
+2012-01-20  Balaji V. Iyer  <balaji.v.iyer@intel.com>
+
+	* call.c (convert_like_real): Type conversion is ignored if array
+	notation is present as a parameter.
+	* cp-array-notation.c (find_rank): Added a new parameter called
+	ignore_builtin_fn.  Also handled a case for STATEMENT_LIST.  Finally,
+	added a check to see if the builtin function should be ignored.
+	(extract_array_notation_exprs): Added a new parameter called
+	ignore_builtin_fn.  Also added a check to see for ignore_builtin_fn.
+	(replace_array_notations): Likewise.
+	(build_x_array_notation_expr): Modified find_rank call to add a bool.
+	Also added a check if the funtion is a builtin array notation function.
+	Added a bool parameter to extract_array_notation_exprs, find_rank and
+	replace_array_notations.
+	(fix_builtin_array_notation_fn): New function.
+	(is_builtin_array_notation_fn): Likewise.
+	(build_x_reduce_expr): Likewise.
+	(contains_array_notation_expr): Likewise.
+	(fix_unary_array_notation_exprs): Changed the name of the parameter.
+	Also handled a case check for CALL_EXPR and if so, called
+	fix_builtin_array_notation_fn.
+
 2012-01-17  Balaji V. Iyer  <balaji.v.iyer@intel.com>
 
 	* cp-array-notation.c (max): New function.
diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index 5413eda..e222e04 100644
--- a/gcc/cp/call.c
+++ b/gcc/cp/call.c
@@ -43,6 +43,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "timevar.h"
 #include "cilk.h"
 
+extern bool contains_array_notation_expr (tree);
 /* The various kinds of conversion.  */
 
 typedef enum conversion_kind {
@@ -5638,13 +5639,16 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
 	  else if (t->kind == ck_identity)
 	    break;
 	}
-
-      permerror (input_location, "invalid conversion from %qT to %qT",
-		 TREE_TYPE (expr), totype);
-      if (fn)
-	permerror (DECL_SOURCE_LOCATION (fn),
-		   "  initializing argument %P of %qD", argnum, fn);
-
+      if (flag_enable_cilk && contains_array_notation_expr (expr))
+	;
+      else
+	{
+	  permerror (input_location, "invalid conversion from %qT to %qT",
+		     TREE_TYPE (expr), totype);
+	  if (fn)
+	    permerror (DECL_SOURCE_LOCATION (fn),
+		       "  initializing argument %P of %qD", argnum, fn);
+	}
       return cp_convert (totype, expr);
     }
 
diff --git a/gcc/cp/cp-array-notation.c b/gcc/cp/cp-array-notation.c
index a8667dd..39845f6 100644
--- a/gcc/cp/cp-array-notation.c
+++ b/gcc/cp/cp-array-notation.c
@@ -45,20 +45,24 @@
 #include "bitmap.h"
 
 
-void replace_array_notations (tree *, tree *, tree *, int);
-void find_rank (tree array, int *rank);
+void replace_array_notations (tree *, bool, tree *, tree *, int);
+void find_rank (tree, bool, int *);
 static tree fix_conditional_array_notations_1 (tree stmt);
 tree fix_unary_array_notation_exprs (tree stmt);
+static bool is_builtin_array_notation_fn (tree, an_reduce_type *);
+static tree build_x_reduce_expr (tree, enum tree_code, tree, tsubst_flags_t,
+				 an_reduce_type);
+bool contains_array_notation_expr (tree);
 
 /* This function is to find the rank of an array notation expression.
  * For example, an array notation of A[:][:] has a rank of 2.
  */
 void
-find_rank (tree array, int *rank)
+find_rank (tree array, bool ignore_builtin_fn, int *rank)
 {
   tree ii_tree;
   int current_rank = 0, ii = 0;
-  
+  an_reduce_type dummy_type = REDUCE_UNKNOWN;
   if (!array)
     return;
   else if (TREE_CODE (array) == ARRAY_NOTATION_REF)
@@ -73,16 +77,31 @@ find_rank (tree array, int *rank)
       else if (*rank == 0)
 	*rank = current_rank;
     }
+  else if (TREE_CODE (array) == STATEMENT_LIST)
+    {
+      tree_stmt_iterator ii_tsi;
+      for (ii_tsi = tsi_start (array); !tsi_end_p (ii_tsi);
+	   tsi_next (&ii_tsi))
+	find_rank (*tsi_stmt_ptr (ii_tsi), ignore_builtin_fn, rank);
+    }
   else
     {
       if (TREE_CODE (array) == CALL_EXPR
 	  || TREE_CODE (array) == AGGR_INIT_EXPR)
 	{
+	  tree func_name = CALL_EXPR_FN (array);
+	  if (TREE_CODE (func_name) == ADDR_EXPR)
+	    if (ignore_builtin_fn)
+	      if (is_builtin_array_notation_fn (func_name, &dummy_type))
+		/* If it is a builtin function, then we know it returns a
+		 * scalar
+		 */
+		return;
 	  if (TREE_CODE (TREE_OPERAND (array, 0)) == INTEGER_CST)
 	    {
 	      int length = TREE_INT_CST_LOW (TREE_OPERAND (array, 0));
 	      for (ii = 0; ii < length; ii++)
-		find_rank (TREE_OPERAND (array, ii), rank);
+		find_rank (TREE_OPERAND (array, ii), ignore_builtin_fn, rank);
 	    }
 	  else
 	    gcc_unreachable ();
@@ -90,7 +109,7 @@ find_rank (tree array, int *rank)
       else
 	{
 	  for (ii = 0; ii < TREE_CODE_LENGTH (TREE_CODE (array)); ii++)
-	    find_rank (TREE_OPERAND (array, ii), rank);
+	    find_rank (TREE_OPERAND (array, ii), ignore_builtin_fn, rank);
 	}
     }
   return;
@@ -100,10 +119,13 @@ find_rank (tree array, int *rank)
  * expressions inside the subtrees
  */
 void
-extract_array_notation_exprs (tree node, tree **array_list, int *list_size)
+extract_array_notation_exprs (tree node, bool ignore_builtin_fn,
+			      tree **array_list, int *list_size)
 {
   int ii = 0;
   tree *new_array_list = NULL;
+  an_reduce_type dummy_type = REDUCE_UNKNOWN;
+  
   if (!node)
     return;
   else if (TREE_CODE (node) == ARRAY_NOTATION_REF)
@@ -122,18 +144,36 @@ extract_array_notation_exprs (tree node, tree **array_list, int *list_size)
     {
       tree_stmt_iterator ii_tsi;
       for (ii_tsi = tsi_start (node); !tsi_end_p (ii_tsi); tsi_next (&ii_tsi))
-	extract_array_notation_exprs (*tsi_stmt_ptr (ii_tsi), array_list,
-				      list_size);
+	extract_array_notation_exprs (*tsi_stmt_ptr (ii_tsi), ignore_builtin_fn,
+				      array_list, list_size);
     }
   else if (TREE_CODE (node) == CALL_EXPR || TREE_CODE (node) == AGGR_INIT_EXPR)
     {
+      if (is_builtin_array_notation_fn (CALL_EXPR_FN (node), &dummy_type))
+	{
+	  if (ignore_builtin_fn)
+	    return;
+	  else
+	    {
+	      ii = *list_size;
+	      new_array_list = (tree *) xrealloc (*array_list, (ii + 1) *
+						  sizeof (tree));
+	      gcc_assert (new_array_list);
+	      new_array_list[ii] = node;
+	      ii++;
+	      *list_size = ii;
+	      *array_list = new_array_list;
+	      return;
+	    }
+	}
       if (TREE_CODE (TREE_OPERAND (node, 0)) == INTEGER_CST)
 	{
 	  int length = TREE_INT_CST_LOW (TREE_OPERAND (node, 0));
 
 	  for (ii = 0; ii < length; ii++)
-	    extract_array_notation_exprs (TREE_OPERAND (node, ii), array_list,
-					  list_size);
+	    extract_array_notation_exprs
+	      (TREE_OPERAND (node, ii), ignore_builtin_fn, array_list,
+	       list_size);
 	}
       else
 	gcc_unreachable  (); /* should not get here */
@@ -142,8 +182,8 @@ extract_array_notation_exprs (tree node, tree **array_list, int *list_size)
   else
     {
       for (ii = 0; ii < TREE_CODE_LENGTH (TREE_CODE (node)); ii++)
-	extract_array_notation_exprs (TREE_OPERAND (node, ii), array_list,
-				      list_size);
+	extract_array_notation_exprs (TREE_OPERAND (node, ii),
+				      ignore_builtin_fn, array_list, list_size);
     }
   return;
 }
@@ -152,10 +192,11 @@ extract_array_notation_exprs (tree node, tree **array_list, int *list_size)
  * appropriate scalar equivalent
  */
 void
-replace_array_notations (tree *orig, tree *list, tree *array_operand,
-			 int array_size)
+replace_array_notations (tree *orig, bool ignore_builtin_fn, tree *list,
+			 tree *array_operand, int array_size)
 {
   int ii = 0;
+  an_reduce_type dummy_type = REDUCE_UNKNOWN;
   
   if (array_size == 0 || *list == NULL || !*orig)
     return;
@@ -172,18 +213,31 @@ replace_array_notations (tree *orig, tree *list, tree *array_operand,
     {
       tree_stmt_iterator ii_tsi;
       for (ii_tsi = tsi_start (*orig); !tsi_end_p (ii_tsi); tsi_next (&ii_tsi))
-	replace_array_notations (tsi_stmt_ptr (ii_tsi), list, array_operand,
-				 array_size);
+	replace_array_notations (tsi_stmt_ptr (ii_tsi), ignore_builtin_fn,
+				 list, array_operand, array_size);
     }
   else if (TREE_CODE (*orig) == CALL_EXPR
 	   || TREE_CODE (*orig) == AGGR_INIT_EXPR)
     {
+      if (is_builtin_array_notation_fn (CALL_EXPR_FN (*orig), &dummy_type))
+	{
+	  if (!ignore_builtin_fn)
+	    {
+	      for (ii = 0; ii < array_size; ii++)
+		{
+		  if (*orig == list[ii])
+		    *orig = array_operand[ii];
+		}
+	    }
+	  return;
+	}
       if (TREE_CODE (TREE_OPERAND (*orig, 0)) == INTEGER_CST)
 	{
 	  int length = TREE_INT_CST_LOW (TREE_OPERAND (*orig, 0));
 	  for (ii = 0; ii < length; ii++)
-	    replace_array_notations (&TREE_OPERAND (*orig, ii), list,
-				     array_operand, array_size);
+	    replace_array_notations
+	      (&TREE_OPERAND (*orig, ii), ignore_builtin_fn, list,
+	       array_operand, array_size);
 	}
       else
 	gcc_unreachable (); /* should not get here! */
@@ -192,8 +246,9 @@ replace_array_notations (tree *orig, tree *list, tree *array_operand,
     {
       for (ii = 0; ii < TREE_CODE_LENGTH (TREE_CODE (*orig)); ii++)
 	{
-	  replace_array_notations (&TREE_OPERAND (*orig, ii), list,
-				   array_operand, array_size);
+	  replace_array_notations
+	    (&TREE_OPERAND (*orig, ii), ignore_builtin_fn, list,
+	     array_operand, array_size);
 	}
     }
   return;
@@ -235,17 +290,27 @@ build_x_array_notation_expr (tree lhs, enum tree_code modifycode, tree rhs,
   tree ii_tree = NULL_TREE;
   tree *rhs_list = NULL;
   int rhs_list_size = 0;
+  an_reduce_type type = REDUCE_UNKNOWN;
   
-  find_rank (lhs, &lhs_rank);
-  find_rank (rhs, &rhs_rank);
+  find_rank (lhs, true, &lhs_rank);
+  find_rank (rhs, true, &rhs_rank);
 
   /* If both are scalar, then no reason to do any of the components inside this
    * function... a simple build_x_modify_expr would do.
    */
   if (lhs_rank == 0 && rhs_rank == 0)
     return NULL_TREE;
+
+  if (TREE_CODE (rhs) == CALL_EXPR)
+    {
+      if (is_builtin_array_notation_fn (CALL_EXPR_FN (rhs), &type))
+	{
+	  loop = build_x_reduce_expr (lhs, modifycode, rhs, complain, type);
+	  return loop;
+	}
+    }
   
-  extract_array_notation_exprs (rhs, &rhs_list, &rhs_list_size);
+  extract_array_notation_exprs (rhs, true, &rhs_list, &rhs_list_size);
 
   if (lhs_rank == 0 && rhs_rank != 0)
     {
@@ -540,7 +605,7 @@ build_x_array_notation_expr (tree lhs, enum tree_code modifycode, tree rhs,
 		}
 	    }
 	}
-      replace_array_notations (&rhs, rhs_list, rhs_array_operand,
+      replace_array_notations (&rhs, true, rhs_list, rhs_array_operand,
 				 rhs_list_size);
 	array_expr_rhs = rhs;
     }
@@ -691,11 +756,11 @@ fix_conditional_array_notations_1 (tree stmt)
     /* otherwise don't even touch the statement */
     return stmt;
 
-  find_rank (cond, &rank);
+  find_rank (cond, true, &rank);
   if (rank == 0)
     return stmt;  
   
-  extract_array_notation_exprs (cond, &array_list, &list_size);
+  extract_array_notation_exprs (cond, true, &array_list, &list_size);
 
   if (*array_list == NULL_TREE || list_size == 0)
     return stmt;
@@ -862,7 +927,7 @@ fix_conditional_array_notations_1 (tree stmt)
 	    }
 	}
     }
-  replace_array_notations (&stmt, array_list, array_operand, list_size);
+  replace_array_notations (&stmt, true, array_list, array_operand, list_size);
 
   for (ii = 0; ii < rank; ii++)
     {
@@ -1154,8 +1219,422 @@ fix_array_notation_exprs (tree t)
   return t;
 }
 
+static tree
+fix_builtin_array_notation_fn (tree an_builtin_fn, tree *new_var)
+{
+  tree new_var_type = NULL_TREE, func_parm, new_expr, new_yes_expr, new_no_expr;
+  tree new_var_init;
+  an_reduce_type an_type = REDUCE_UNKNOWN;
+  tree *array_list = NULL;
+  int list_size = 0;
+  int rank = 0, ii = 0, jj = 0;
+  tree **array_ops, *array_var, *array_operand, jj_tree, loop;
+  tree **array_value, **array_stride, **array_length, **array_start;
+  tree *body_label, *body_label_expr, *exit_label, *exit_label_expr;
+  tree *compare_expr, *if_stmt_label, *expr_incr, *ind_init;
+  bool **count_down, **array_vector;
+  
+  if (!is_builtin_array_notation_fn (CALL_EXPR_FN (an_builtin_fn), &an_type))
+    return NULL_TREE;
+
+  func_parm = CALL_EXPR_ARG (an_builtin_fn, 0);
+  while (TREE_CODE (func_parm) == CONVERT_EXPR
+	 || TREE_CODE (func_parm) == NOP_EXPR)
+    func_parm = TREE_OPERAND (func_parm, 0);
+  
+  
+  find_rank (an_builtin_fn, false, &rank);
+  if (rank == 0)
+    return an_builtin_fn;
+  else if (rank > 1 
+	   && (an_type == REDUCE_MAX_INDEX  || an_type == REDUCE_MIN_INDEX))
+    { 
+      error ("__sec_reduce_min_ind or __sec_reduce_max_ind cannot have arrays"
+	     " with dimension greater than 1.");
+      fnotice (stderr, "confused by earlier errors, bailing out\n"); 
+      exit (ICE_EXIT_CODE);
+    }
+  
+  extract_array_notation_exprs (func_parm, true, &array_list, &list_size);
+
+    switch (an_type)
+    {
+    case REDUCE_ADD:
+    case REDUCE_MUL:
+    case REDUCE_MAX:
+    case REDUCE_MIN:
+      new_var_type = ARRAY_NOTATION_TYPE (array_list[0]);
+      break;
+    case REDUCE_ALL_ZEROS:
+    case REDUCE_ANY_ZEROS:
+      new_var_type = integer_type_node;
+      break;
+    case REDUCE_MAX_INDEX:
+    case REDUCE_MIN_INDEX:
+      new_var_type = integer_type_node;
+      break;
+    default:
+      gcc_unreachable ();
+    }
+   
+  
+  array_ops = (tree **) xmalloc (sizeof (tree *) * list_size);
+  for (ii = 0; ii < list_size; ii++)
+    array_ops[ii] = (tree *) xmalloc (sizeof (tree) * rank);
+  
+  array_vector = (bool **) xmalloc (sizeof (bool *) * list_size);
+  for (ii = 0; ii < list_size; ii++)
+    array_vector[ii] = (bool *) xmalloc (sizeof (bool) * rank);
+
+  array_value = (tree **) xmalloc (sizeof (tree *) * list_size);
+  array_stride = (tree **) xmalloc (sizeof (tree *) * list_size);
+  array_length = (tree **) xmalloc (sizeof (tree *) * list_size);
+  array_start = (tree **) xmalloc (sizeof (tree *) * list_size);
+
+  for (ii = 0; ii < list_size; ii++)
+    {
+      array_value[ii]  = (tree *) xmalloc (sizeof (tree) * rank);
+      array_stride[ii] = (tree *) xmalloc (sizeof (tree) * rank);
+      array_length[ii] = (tree *) xmalloc (sizeof (tree) * rank);
+      array_start[ii]  = (tree *) xmalloc (sizeof (tree) * rank);
+    }
+
+  body_label = (tree *) xmalloc(sizeof (tree) * rank);
+  body_label_expr = (tree *) xmalloc (sizeof (tree) * rank);
+  exit_label = (tree *) xmalloc (sizeof (tree) * rank);
+  exit_label_expr = (tree *) xmalloc (sizeof (tree) * rank);
+  compare_expr = (tree *) xmalloc (sizeof (tree) * rank);
+  if_stmt_label = (tree *) xmalloc (sizeof (tree) * rank);
+  
+  expr_incr = (tree *) xmalloc (sizeof (tree) * rank);
+  ind_init = (tree *) xmalloc (sizeof (tree) * rank);
+  
+  count_down = (bool **) xmalloc (sizeof (bool *) * list_size);
+  for (ii = 0; ii < list_size; ii++)
+    count_down[ii] = (bool *) xmalloc (sizeof (bool) * rank);
+
+  array_operand = (tree *) xmalloc (sizeof (tree) * list_size);
+  
+  array_var = (tree *) xmalloc (sizeof (tree) * rank);
+
+  for (ii = 0; ii < list_size; ii++)
+    {
+      jj = 0;
+      for (jj_tree = array_list[ii];
+	   jj_tree && TREE_CODE (jj_tree) == ARRAY_NOTATION_REF;
+	   jj_tree = ARRAY_NOTATION_ARRAY (jj_tree))
+	{
+	  array_ops[ii][jj] = jj_tree;
+	  jj++;
+	}
+    }
+
+  for (ii = 0; ii < list_size; ii++)
+    {
+      if (TREE_CODE (array_list[ii]) == ARRAY_NOTATION_REF)
+	{
+	  for (jj = 0; jj < rank; jj++)
+	    {
+	      if (TREE_CODE (array_ops[ii][jj]) == ARRAY_NOTATION_REF)
+		{
+		  array_value[ii][jj] =
+		    ARRAY_NOTATION_ARRAY (array_ops[ii][jj]);
+		  array_start[ii][jj] =
+		    ARRAY_NOTATION_START (array_ops[ii][jj]);
+		  array_length[ii][jj] =
+		    ARRAY_NOTATION_LENGTH (array_ops[ii][jj]);
+		  array_stride[ii][jj] =
+		    ARRAY_NOTATION_STRIDE (array_ops[ii][jj]);
+		  array_vector[ii][jj] = true;
+
+		  if (!TREE_CONSTANT (array_length[ii][jj]))
+		      count_down[ii][jj] = false;
+		  else if (tree_int_cst_lt
+			   (array_length[ii][jj],
+			    build_int_cst (TREE_TYPE (array_length[ii][jj]),
+					   0)))
+		    count_down[ii][jj] = true;
+		  else
+		    count_down[ii][jj] = false;
+		}
+	      else
+		array_vector[ii][jj] = false;
+	    }
+	}
+    }
+
+  loop = alloc_stmt_list ();
+
+
+  for (ii = 0; ii < rank; ii++)
+    {
+      array_var[ii] = build_decl (UNKNOWN_LOCATION, VAR_DECL, NULL_TREE,
+				  integer_type_node);
+      ind_init[ii] =
+	build_modify_expr (UNKNOWN_LOCATION, array_var[ii],
+			   TREE_TYPE (array_var[ii]), NOP_EXPR,
+			   UNKNOWN_LOCATION,
+			   build_int_cst (TREE_TYPE (array_var[ii]), 0),
+			   TREE_TYPE (array_var[ii]));	
+    }
+
+  for (ii = 0; ii < rank ; ii++)
+    {
+      /* this will create the if statement label */
+      if_stmt_label[ii] = build_decl (UNKNOWN_LOCATION, LABEL_DECL, NULL_TREE,
+				      void_type_node);
+      DECL_CONTEXT (if_stmt_label[ii]) = current_function_decl;
+      DECL_ARTIFICIAL (if_stmt_label[ii]) = 0;
+      DECL_IGNORED_P (if_stmt_label[ii]) = 1;
+  
+      /* this label statment will point to the loop body */
+      body_label[ii] = build_decl (UNKNOWN_LOCATION, LABEL_DECL, NULL_TREE,
+				   void_type_node);
+      DECL_CONTEXT (body_label[ii]) = current_function_decl;
+      DECL_ARTIFICIAL (body_label[ii]) = 0;
+      DECL_IGNORED_P (body_label[ii]) = 1;
+      body_label_expr[ii] = build1 (LABEL_EXPR, void_type_node, body_label[ii]);
+
+      /* this will create the exit label..i.e. where the while loop will branch
+	 out of
+      */
+      exit_label[ii] = build_decl (UNKNOWN_LOCATION, LABEL_DECL, NULL_TREE,
+				   void_type_node);
+      DECL_CONTEXT (exit_label[ii]) = current_function_decl;
+      DECL_ARTIFICIAL (exit_label[ii]) = 0;
+      DECL_IGNORED_P (exit_label[ii]) = 1;
+      exit_label_expr[ii] = build1 (LABEL_EXPR, void_type_node, exit_label[ii]);
+    }
+
+  for (ii = 0; ii < list_size; ii++)
+    {
+      if (array_vector[ii][0])
+	{
+	  array_operand[ii] = array_value[ii][rank - 1];
+	  gcc_assert (array_operand[ii]);
+
+	  for (jj = rank - 1; jj >= 0; jj--)
+	    {
+	      if (count_down[ii][jj])
+		{
+		  /* Array[start_index - (induction_var * stride)] */
+		  array_operand[ii] = build_array_ref
+		    (UNKNOWN_LOCATION, array_operand[ii],
+		     build2 (MINUS_EXPR, TREE_TYPE (array_var[jj]),
+			     array_start[ii][jj],
+			     build2 (MULT_EXPR, TREE_TYPE (array_var[jj]),
+				     array_var[jj], array_stride[ii][jj])));
+		}
+	      else
+		{
+		  /* Array[start_index + (induction_var * stride)] */
+		  array_operand[ii] = build_array_ref
+		    (UNKNOWN_LOCATION, array_operand[ii],
+		     build2 (PLUS_EXPR, TREE_TYPE (array_var[jj]),
+			     array_start[ii][jj],
+			     build2 (MULT_EXPR, TREE_TYPE (array_var[jj]),
+				     array_var[jj], array_stride[ii][jj])));
+		}
+	    }
+	}
+    }
+  replace_array_notations (&func_parm, true, array_list, array_operand,
+			   list_size);
+
+  for (ii = 0; ii < rank; ii++)
+    {
+      expr_incr[ii] =
+	build2 (MODIFY_EXPR, void_type_node, array_var[ii],
+		build2 (PLUS_EXPR, TREE_TYPE (array_var[ii]), array_var[ii],
+			build_int_cst (TREE_TYPE (array_var[ii]), 1)));
+    }
+  
+  for (jj = 0; jj < rank; jj++)
+    {
+      if (rank && expr_incr[jj])
+	{
+	  if (count_down[0][jj])
+	    compare_expr[jj] =
+	      build2 (LT_EXPR, boolean_type_node, array_var[jj],
+		      build2 (MULT_EXPR, TREE_TYPE (array_var[jj]),
+			      array_length[0][jj],
+			      build_int_cst (TREE_TYPE (array_var[jj]), -1)));
+	  else
+	    compare_expr[jj] = build2 (LT_EXPR, boolean_type_node,
+				       array_var[jj], array_length[0][jj]);
+	}
+    }
+
+  *new_var = build_decl (UNKNOWN_LOCATION, VAR_DECL, NULL_TREE, new_var_type);
+  gcc_assert (*new_var);
+
+  switch (an_type)
+    {
+    case REDUCE_ADD:
+      new_var_init = build_x_modify_expr
+	(*new_var, NOP_EXPR, build_int_cst (new_var_type, 0), 1);
+      new_expr = build_x_modify_expr (*new_var, PLUS_EXPR, func_parm, 1);
+      break;
+    case REDUCE_MUL:
+      new_var_init = build_x_modify_expr
+	(*new_var, NOP_EXPR, build_int_cst (new_var_type, 1), 1);
+      new_expr = build_x_modify_expr (*new_var, MULT_EXPR, func_parm, 1);
+      break;
+    case REDUCE_ALL_ZEROS:
+      new_var_init = build_x_modify_expr
+	(*new_var, NOP_EXPR, build_int_cst (new_var_type, 1), 1);
+      /* Initially you assume everything is zero, now if we find a case where
+       * it is NOT true, then we set the result to false. Otherwise
+       * we just keep the previous value
+       */
+      new_yes_expr = build_x_modify_expr
+	(*new_var, NOP_EXPR, build_int_cst (TREE_TYPE (*new_var), 0), 1);
+      new_no_expr = build_x_modify_expr (*new_var, NOP_EXPR, *new_var, 1);
+      new_expr = build_x_conditional_expr (func_parm, new_yes_expr,
+					   new_no_expr, 1);
+      break;
+    case REDUCE_ANY_ZEROS:
+      new_var_init = build_x_modify_expr
+	(*new_var, NOP_EXPR, build_int_cst (new_var_type, 0), 1);
+      /* Initially we assume there are NO zeros in the list. When we find
+       * a non-zero, we keep the previous value. If we find a zero, we
+       * set the value to true
+       */
+      new_no_expr = build_x_modify_expr
+	(*new_var, NOP_EXPR, build_int_cst (TREE_TYPE (*new_var), 1), 1);
+      new_yes_expr = build_x_modify_expr (*new_var, NOP_EXPR, *new_var, 1);
+      new_expr = build_x_conditional_expr (func_parm, new_yes_expr,
+					   new_no_expr, 1);      
+      break;
+    case REDUCE_MAX:
+      if (INTEGRAL_TYPE_P (new_var_type))
+	new_var_init = build_x_modify_expr
+	  (*new_var, NOP_EXPR, TYPE_MIN_VALUE (new_var_type), 1);
+      else /* Otherwise, we pick the first item in the array */
+	new_var_init = build_x_modify_expr
+	  (*new_var, NOP_EXPR,
+	   build_array_ref (UNKNOWN_LOCATION,
+			    TREE_OPERAND (array_operand[0], 0),
+			    build_int_cst (integer_type_node, 0)), 1);
+      new_no_expr  = build_x_modify_expr (*new_var, NOP_EXPR, *new_var, 1);
+      new_yes_expr = build_x_modify_expr (*new_var, NOP_EXPR, func_parm, 1);
+      new_expr = build_x_conditional_expr
+	(build2 (LT_EXPR, TREE_TYPE (*new_var), *new_var, func_parm),
+	 new_yes_expr, new_no_expr, 1);      
+      break;
+    case REDUCE_MIN:
+      if (INTEGRAL_TYPE_P (new_var_type))
+	new_var_init = build_x_modify_expr
+	  (*new_var, NOP_EXPR, TYPE_MAX_VALUE (new_var_type), 1);
+      else /* Otherwise, we the first item in the array */
+	new_var_init = build_x_modify_expr
+	  (*new_var, NOP_EXPR,
+	   build_array_ref (UNKNOWN_LOCATION,
+			    TREE_OPERAND (array_operand[0], 0),
+			    build_int_cst (integer_type_node, 0)), 1);
+      new_no_expr  = build_x_modify_expr (*new_var, NOP_EXPR, *new_var, 1);
+      new_yes_expr = build_x_modify_expr (*new_var, NOP_EXPR, func_parm, 1);
+      new_expr = build_x_conditional_expr
+	(build2 (GT_EXPR, TREE_TYPE (*new_var), *new_var, func_parm),
+	 new_yes_expr, new_no_expr, 1);
+      break;
+    case REDUCE_MAX_INDEX:
+      new_var_init = build_x_modify_expr
+	(*new_var, NOP_EXPR, build_int_cst (new_var_type, 0), 1);
+      new_no_expr  = build_x_modify_expr (*new_var, NOP_EXPR, *new_var, 1);
+      if (list_size > 1) /* this means there is more than 1 */
+	new_yes_expr = build_x_modify_expr (*new_var, NOP_EXPR, array_var[0],
+					    1);
+      else				    
+	new_yes_expr = build_x_modify_expr
+	  (*new_var, NOP_EXPR, TREE_OPERAND (array_operand[0], 1), 1);
+      
+      new_expr = build_x_conditional_expr
+	(build2 (LT_EXPR, TREE_TYPE (*new_var), *new_var, func_parm),
+	 new_yes_expr, new_no_expr, 1);
+      break;
+    case REDUCE_MIN_INDEX:
+      new_var_init = build_x_modify_expr
+	(*new_var, NOP_EXPR, build_int_cst (new_var_type, 0), 1);
+      new_no_expr  = build_x_modify_expr (*new_var, NOP_EXPR, *new_var, 1);
+      if (list_size > 1)
+	new_yes_expr = build_x_modify_expr (*new_var, NOP_EXPR, array_var[0],
+					    1);
+      else
+	new_yes_expr = build_x_modify_expr
+	  (*new_var, NOP_EXPR, TREE_OPERAND (array_operand[0], 1), 1);
+      
+      new_expr = build_x_conditional_expr
+	(build2 (GT_EXPR, TREE_TYPE (*new_var), *new_var, func_parm),
+	 new_yes_expr, new_no_expr, 1);
+      break;
+    default:
+      gcc_unreachable ();
+      break;
+    }
+
+  append_to_statement_list (new_var_init, &loop);
+  
+  for (ii = 0; ii < rank; ii++)
+    {
+      append_to_statement_list (ind_init [ii], &loop);
+
+      append_to_statement_list
+	(build1 (LABEL_EXPR, void_type_node, if_stmt_label[ii]), &loop);
+      append_to_statement_list
+	(build3 (COND_EXPR, void_type_node, compare_expr[ii],
+		 build1 (GOTO_EXPR, void_type_node, body_label[ii]),
+		 build1 (GOTO_EXPR, void_type_node, exit_label[ii])), &loop);
+      append_to_statement_list (body_label_expr[ii], &loop);
+    }
+					   
+  append_to_statement_list (new_expr, &loop);
+  
+  for (ii = rank - 1; ii >= 0; ii--)
+    {
+      append_to_statement_list (expr_incr[ii], &loop);
+      append_to_statement_list
+	(build1 (GOTO_EXPR, void_type_node, if_stmt_label[ii]), &loop);
+      append_to_statement_list (exit_label_expr[ii], &loop);
+    }
+
+  free (body_label);
+  free (body_label_expr);
+  free (exit_label);
+  free (exit_label_expr);
+  free (compare_expr);
+  free (if_stmt_label);
+  free (expr_incr);
+  free (ind_init);
+  free (array_operand);
+  free (array_var);
+  
+  for (ii = 0; ii < list_size; ii++)
+    {
+      free (count_down[ii]);
+      free (array_value[ii]);
+      free (array_stride[ii]);
+      free (array_length[ii]);
+      free (array_start[ii]);
+      free (array_ops[ii]);
+      free (array_vector[ii]);
+    }
+
+  free (count_down);
+  free (array_value);
+  free (array_stride);
+  free (array_length);
+  free (array_start);
+  free (array_ops);
+  free (array_vector);
+
+  
+  return loop;
+}
+
+
 tree
-fix_unary_array_notation_exprs (tree stmt)
+fix_unary_array_notation_exprs (tree orig_stmt)
 {
 
   tree *array_list = NULL;
@@ -1166,11 +1645,35 @@ fix_unary_array_notation_exprs (tree stmt)
   tree *body_label, *body_label_expr, *exit_label, *exit_label_expr;
   tree *compare_expr, *if_stmt_label, *expr_incr, *ind_init;
   bool **count_down, **array_vector;
-  find_rank (stmt, &rank);
+  tree builtin_loop, stmt = NULL_TREE, new_var = NULL_TREE;
+  
+  find_rank (orig_stmt, false, &rank);
   if (rank == 0)
-    return stmt;  
+    return orig_stmt;  
   
-  extract_array_notation_exprs (stmt, &array_list, &list_size);
+  extract_array_notation_exprs (orig_stmt, false, &array_list, &list_size);
+
+  stmt = alloc_stmt_list ();
+  for (ii = 0; ii < list_size; ii++)
+    {
+      if (TREE_CODE (array_list[ii]) == CALL_EXPR
+	  || TREE_CODE (array_list[ii]) == AGGR_INIT_EXPR)
+	{
+	  builtin_loop =
+	    fix_builtin_array_notation_fn (array_list[ii], &new_var);
+	  append_to_statement_list (builtin_loop, &stmt);
+	  replace_array_notations (&orig_stmt, false, &array_list[ii],
+				   &new_var, 1);
+	}
+    }
+  append_to_statement_list (orig_stmt, &stmt);
+  rank = 0;
+  list_size = 0;
+  array_list = NULL;
+  extract_array_notation_exprs (stmt, true, &array_list, &list_size);
+  find_rank (stmt, true, &rank);
+  if (rank == 0)
+    return stmt;
   
   if (*array_list == NULL_TREE || list_size == 0)
     return stmt;
@@ -1334,7 +1837,7 @@ fix_unary_array_notation_exprs (tree stmt)
 	    }
 	}
     }
-  replace_array_notations (&stmt, array_list, array_operand, list_size);
+  replace_array_notations (&stmt, true, array_list, array_operand, list_size);
 
   for (ii = 0; ii < rank; ii++)
     {
@@ -1416,3 +1919,97 @@ fix_unary_array_notation_exprs (tree stmt)
   stmt = loop;
   return stmt;
 }
+
+static bool
+is_builtin_array_notation_fn (tree func_name, an_reduce_type *type)
+{
+  const char *function_name;
+
+  if (!func_name)
+    return false;
+
+  if (TREE_CODE (func_name) == IDENTIFIER_NODE)
+    function_name = IDENTIFIER_POINTER (DECL_NAME (func_name));
+  else if (TREE_CODE (func_name) == ADDR_EXPR)
+    {
+      func_name = TREE_OPERAND (func_name, 0);
+      if (TREE_CODE (func_name) == FUNCTION_DECL)
+	function_name = IDENTIFIER_POINTER (DECL_NAME (func_name));
+    }
+  
+  if (!function_name)
+    return false;
+
+  if (!strcmp (function_name, "__sec_reduce_add"))
+    {
+      *type = REDUCE_ADD;
+      return true;
+    }
+  else if (!strcmp (function_name, "__sec_reduce_mul"))
+    {
+      *type = REDUCE_MUL;
+      return true;
+    }
+  else if (!strcmp (function_name, "__sec_reduce_all_zeros"))
+    {
+      *type = REDUCE_ALL_ZEROS;
+      return true;
+    }
+  else if (!strcmp (function_name, "__sec_reduce_any_zeros"))
+    {
+      *type = REDUCE_ANY_ZEROS;
+      return true;
+    }
+  else if (!strcmp (function_name, "__sec_reduce_max"))
+    {
+      *type = REDUCE_MAX;
+      return true;
+    }
+  else if (!strcmp (function_name, "__sec_reduce_min"))
+    {
+      *type = REDUCE_MIN;
+      return true;
+    }
+  else if (!strcmp (function_name, "__sec_reduce_min_ind"))
+    {
+      *type = REDUCE_MIN_INDEX;
+      return true;
+    }
+  else if (!strcmp (function_name, "__sec_reduce_max_ind"))
+    {
+      *type = REDUCE_MAX_INDEX;
+      return true;
+    }
+  else
+    {
+      *type = REDUCE_UNKNOWN;
+      return false;
+    }
+  return false;
+}
+    
+
+static tree
+build_x_reduce_expr (tree lhs, enum tree_code modifycode, tree rhs,
+		     tsubst_flags_t complain, an_reduce_type type)
+{
+  if (!type)
+    {
+      return build_x_modify_expr (lhs, modifycode, rhs, complain);
+    }
+  return NULL_TREE;
+}
+      
+bool
+contains_array_notation_expr (tree expr)
+{
+  tree *array_list = NULL;
+  int list_size = 0;
+  
+  extract_array_notation_exprs (expr, false, &array_list, &list_size);
+  if (*array_list == NULL || list_size == 0)
+    return false;
+  else
+    return true;
+}
+    
diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index fd35211..3979d78 100644
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -41,7 +41,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "tree-pretty-print.h"
 #include "parser.h"
 
-extern void extract_array_notation_exprs (tree, tree **, int *);
+extern void extract_array_notation_exprs (tree, bool, tree **, int *);
 extern tree fix_unary_array_notation_exprs (tree);
 struct pragma_simd_values local_simd_values;
 
diff --git a/gcc/testsuite/ChangeLog.cilk b/gcc/testsuite/ChangeLog.cilk
index 1071752..9fa7413 100644
--- a/gcc/testsuite/ChangeLog.cilk
+++ b/gcc/testsuite/ChangeLog.cilk
@@ -1,3 +1,7 @@
+2012-01-21  Balaji V. Iyer  <balaji.v.iyer@intel.com>
+
+	*  g++.dg/cilk-plus/array_notation_tests/builtin_funcs.cc: New.
+
 2012-01-17  Balaji V. Iyer  <balaji.v.iyer@intel.com>
 
 	* g++.dg/cilk-plus/array_notation_tests/predecr_test.cc: New.
diff --git a/gcc/testsuite/g++.dg/cilk-plus/array_notation_tests/builtin_funcs.cc b/gcc/testsuite/g++.dg/cilk-plus/array_notation_tests/builtin_funcs.cc
new file mode 100644
index 0000000..f5b06da
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cilk-plus/array_notation_tests/builtin_funcs.cc
@@ -0,0 +1,92 @@
+#if HAVE_IO
+#include <iostream> 
+#endif
+#include <cstdlib>
+
+extern int funct(int x);
+extern int funct2(int x, int y);
+extern void func_ptr (int *x);
+
+/* char __sec_reduce_add (int *); */
+int main(int argc, char **argv)
+{
+  int array[10], array2[10], x = 0, y;
+  int x_correct, y_correct;
+
+  for (int ii = 0; ii < 10; ii++)
+    {
+      array[ii] = 1+ii;
+      array2[ii]= 2;
+    }
+
+  x = __sec_reduce_max (array[:] + array2[:]);
+  y = __sec_reduce_max_ind (array[:] + array2[:]);
+#if HAVE_IO
+  std::cout <<  "Max = " << x << " Max Index = " << y << std::endl;
+#endif
+
+  x = __sec_reduce_max (array[0:5:1] + array2[5:5:1]);
+  y = __sec_reduce_max_ind (array[0:5] + array2[5:5:1]);
+#if HAVE_IO
+  std::cout <<  "Max = " << x << " Max Index = " << y << std::endl;
+#endif
+
+  x = __sec_reduce_min (array[:] + array2[:]);
+  y = __sec_reduce_min_ind (array[:] + array2[:]);
+#if HAVE_IO
+  std::cout <<  "Min = " << x << " Min Index = " << y << std::endl;
+#endif
+
+  x = __sec_reduce_min (array[0:5:1] + array2[5:5:1]);
+  y = __sec_reduce_min_ind (array[0:5] + array2[5:5:1]);
+#if HAVE_IO
+  std::cout <<  "Min = " << x << " Min Index = " << y << std::endl;
+#endif
+  
+  x = __sec_reduce_add (array[:] + array2[:]);
+  y = __sec_reduce_mul (array[:] + array2[:]);
+
+  x_correct = 0;
+  y_correct = 1;
+  for (int ii = 0; ii < 10; ii++)
+    {
+      x_correct += (array[ii] + array2[ii]);
+      y_correct *= (array[ii] + array2[ii]);
+    }
+#if HAVE_IO
+  std::cout <<  "Add          = " << x 
+    << " Multiply           = " << y << std::endl;
+  std::cout <<  "Add(Correct) = " << x_correct 
+    << " Multiply (Correct) = " << y_correct << std::endl;
+#endif
+
+  x = __sec_reduce_add (array[0:5:1] + array2[5:5:1]);
+  y = __sec_reduce_mul (array[0:5]   + array2[5:5:1]);
+  
+  x_correct = 0;
+  y_correct = 1;
+  for (int ii = 0; ii < 5; ii++)
+    {
+      x_correct += (array[ii] + array2[5+ii]);
+      y_correct *= (array[ii] + array2[5+ii]);
+    }
+#if HAVE_IO
+  std::cout <<  "Add          = " << x 
+    << " Multiply           = " << y << std::endl;
+  std::cout <<  "Add(Correct) = " << x_correct 
+    << " Multiply (Correct) = " << y_correct << std::endl;
+#endif
+
+    array[:] = argc - atoi ("1");
+
+    for (int ii = 0; ii < 10; ii++)
+      array2[ii] = argc - ii;
+
+  x = __sec_reduce_all_zeros (array[0:5:1]);
+  y = __sec_reduce_any_zeros (array2[:]);
+#if HAVE_IO
+  std::cout <<  "All Zeros = " << x << " Any Zeros = " << y << std::endl;
+#endif
+
+  return 0;
+}
diff --git a/gcc/tree.h b/gcc/tree.h
index 051187d..90f9653 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -73,8 +73,6 @@ struct reduction_values
   int not_reduced;
   struct reduction_values *ptr_next;
 };
-  
-
 
 /* bviyer: Since we can have multiple pragma simd, this will hold the values of
  * each of the pragma simd and then as soon as it finds a for loop
@@ -105,11 +103,19 @@ struct pragma_simd_values
   struct pragma_simd_values *ptr_next;
 };
 
-
-
-
 extern struct pragma_simd_values *psv_head;
 
+typedef enum array_notation_reduce_type {
+  REDUCE_UNKNOWN = 0,
+  REDUCE_ADD,
+  REDUCE_MUL,
+  REDUCE_ALL_ZEROS,
+  REDUCE_ANY_ZEROS,
+  REDUCE_MAX,
+  REDUCE_MIN,
+  REDUCE_MAX_INDEX,
+  REDUCE_MIN_INDEX
+} an_reduce_type;
 
 
 #undef DEFTREECODE
