diff --git a/gcc/cp/ChangeLog.cilk b/gcc/cp/ChangeLog.cilk
index 06ef1ec..072a6de 100644
--- a/gcc/cp/ChangeLog.cilk
+++ b/gcc/cp/ChangeLog.cilk
@@ -1,3 +1,29 @@
+2012-01-17  Balaji V. Iyer  <balaji.v.iyer@intel.com>
+
+	* cp-array-notation.c (max): New function.
+	(fix_unary_array_notation_exprs): Likewise.
+	(build_x_array_notation_expr): Added a check to see if we get an
+	expression has a rank of 0.  Also added code to handle a case where
+	a function call with array notation as a parameter that results a
+	scalar value.  Also added a check if lhs_rank is zero.  Changed
+	modifycode to NOP_EXPR.  Replaced all lhs_rank in for-loop conditions
+	to max of lhs and rhs rank.  Added a check to see if array_expr_lhs is
+	null, if so then just use lhs.
+	(fix_conditional_array_notations): Renamed to fix_array_notation_exprs.
+	Also added a case for POSTINCREMENT_EXPR, POSTDECREMENT_EXPR,
+	PREDECREMENT_EXPR, PREINCREMENT_EXPR.
+	* cp-tree.h: Renamed fix_conditional_array_notations to
+	fix_array_notation_exprs.
+	* parser.c (cp_parser_assignment_expression): Modified to handle a
+	function-call that has array-notation as a parameter which will return
+	a single scalar value.
+	(cp_parser_compound_statement): Renamed fix_conditional array_notations
+	to fix_array_notation_exprs and make sure it is called only if
+	flag_enable_cilk is set.
+	* typeck.c (lvalue_or_else): Removed a error check for
+	ARRAY_NOTATION_REF, if flag_enable_cilk is defined.
+	(cp_build_addr_expr_1): Likewise.
+
 2012-01-12  Balaji V. Iyer  <balaji.v.iyer@intel.com>
 
 	* cp-array-notation.c (fix_conditional_array_notations): New function.
diff --git a/gcc/cp/cp-array-notation.c b/gcc/cp/cp-array-notation.c
index dec87bb..a8667dd 100644
--- a/gcc/cp/cp-array-notation.c
+++ b/gcc/cp/cp-array-notation.c
@@ -48,6 +48,7 @@
 void replace_array_notations (tree *, tree *, tree *, int);
 void find_rank (tree array, int *rank);
 static tree fix_conditional_array_notations_1 (tree stmt);
+tree fix_unary_array_notation_exprs (tree stmt);
 
 /* This function is to find the rank of an array notation expression.
  * For example, an array notation of A[:][:] has a rank of 2.
@@ -198,6 +199,16 @@ replace_array_notations (tree *orig, tree *list, tree *array_operand,
   return;
 }
 
+/* this is a small function that will give the max of 2 integers */
+static int
+max (int x, int y)
+{
+  if (x > y)
+    return x;
+  else
+    return y;
+}
+
 /* this function is synonymous to the build_x_modify_expr. This function
  * will build the equivalent array notation expression
  */
@@ -228,13 +239,22 @@ build_x_array_notation_expr (tree lhs, enum tree_code modifycode, tree rhs,
   find_rank (lhs, &lhs_rank);
   find_rank (rhs, &rhs_rank);
 
-  extract_array_notation_exprs (rhs, &rhs_list, &rhs_list_size);
+  /* 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;
   
+  extract_array_notation_exprs (rhs, &rhs_list, &rhs_list_size);
+
   if (lhs_rank == 0 && rhs_rank != 0)
     {
-      error ( "Left Hand-side rank cannot be scalar when "
-		"right-hand side is not");
-      return error_mark_node;
+      if (TREE_CODE (rhs) != CALL_EXPR)
+	{
+	  error ( "Left Hand-side rank cannot be scalar when "
+		  "right-hand side is not");
+	  return error_mark_node;
+	}
     }
   if (lhs_rank != 0 && rhs_rank != 0 && lhs_rank != rhs_rank)
     {
@@ -286,12 +306,12 @@ build_x_array_notation_expr (tree lhs, enum tree_code modifycode, tree rhs,
    *
    * In both the scenarios, just checking the LHS_RANK is OK
    */
-  body_label = (tree *) xmalloc (sizeof (tree) * lhs_rank);
-  body_label_expr = (tree *) xmalloc (sizeof (tree) * lhs_rank);
-  exit_label = (tree *) xmalloc (sizeof (tree) * lhs_rank);
-  exit_label_expr = (tree *) xmalloc (sizeof (tree) * lhs_rank);
-  cond_expr = (tree *) xmalloc (sizeof (tree) * lhs_rank);
-  if_stmt_label = (tree *) xmalloc (sizeof (tree) * lhs_rank);
+  body_label = (tree *) xmalloc (sizeof (tree) * max (lhs_rank, rhs_rank));
+  body_label_expr = (tree *) xmalloc (sizeof (tree) * max (lhs_rank, rhs_rank));
+  exit_label = (tree *) xmalloc (sizeof (tree) * max(lhs_rank, rhs_rank));
+  exit_label_expr = (tree *) xmalloc (sizeof (tree) * max(lhs_rank, rhs_rank));
+  cond_expr = (tree *) xmalloc (sizeof (tree) * max (lhs_rank, rhs_rank));
+  if_stmt_label = (tree *) xmalloc (sizeof (tree) * max (lhs_rank, rhs_rank));
 
   lhs_expr_incr = (tree *) xmalloc (sizeof (tree) * lhs_rank);
   rhs_expr_incr = (tree *) xmalloc (sizeof (tree) * rhs_rank);
@@ -310,12 +330,17 @@ build_x_array_notation_expr (tree lhs, enum tree_code modifycode, tree rhs,
   rhs_array_operand = (tree *) xmalloc (sizeof (tree) * rhs_list_size);
 
   ii = 0;
-  for (ii_tree = lhs; ii_tree && TREE_CODE (ii_tree) == ARRAY_NOTATION_REF;
-       ii_tree = ARRAY_NOTATION_ARRAY (ii_tree))
+  if (lhs_rank)
     {
-      lhs_array[ii] = ii_tree;
-      ii++;
+      for (ii_tree = lhs; ii_tree && TREE_CODE (ii_tree) == ARRAY_NOTATION_REF;
+	   ii_tree = ARRAY_NOTATION_ARRAY (ii_tree))
+	{
+	  lhs_array[ii] = ii_tree;
+	  ii++;
+	}
     }
+  else
+    lhs_array[0] = NULL_TREE;
 
   if (rhs_rank)
     {
@@ -370,8 +395,10 @@ build_x_array_notation_expr (tree lhs, enum tree_code modifycode, tree rhs,
 		{
 		  rhs_value[ii][jj]  = ARRAY_NOTATION_ARRAY (rhs_array[ii][jj]);
 		  rhs_start[ii][jj]  = ARRAY_NOTATION_START (rhs_array[ii][jj]);
-		  rhs_length[ii][jj] = ARRAY_NOTATION_LENGTH (rhs_array[ii][jj]);
-		  rhs_stride[ii][jj] = ARRAY_NOTATION_STRIDE (rhs_array[ii][jj]);
+		  rhs_length[ii][jj] =
+		    ARRAY_NOTATION_LENGTH (rhs_array[ii][jj]);
+		  rhs_stride[ii][jj] =
+		    ARRAY_NOTATION_STRIDE (rhs_array[ii][jj]);
 		  rhs_vector[ii][jj] = true;
 		  /* If the stride value is variable (i.e. not constant) then
 		   * assume that the length is positive
@@ -401,7 +428,7 @@ build_x_array_notation_expr (tree lhs, enum tree_code modifycode, tree rhs,
 				    TREE_TYPE (lhs_start[ii]));
 	  lhs_ind_init[ii] = build_modify_expr
 	    (UNKNOWN_LOCATION, lhs_var[ii], TREE_TYPE (lhs_var[ii]),
-	     modifycode,
+	     NOP_EXPR,
 	     UNKNOWN_LOCATION, build_int_cst (TREE_TYPE (lhs_start[ii]), 0),
 	     TREE_TYPE (lhs_start[ii]));
 	  
@@ -417,13 +444,13 @@ build_x_array_notation_expr (tree lhs, enum tree_code modifycode, tree rhs,
 				integer_type_node);
       rhs_ind_init[ii] = build_modify_expr
 	(UNKNOWN_LOCATION, rhs_var[ii], TREE_TYPE (rhs_var[ii]),
-	 modifycode,
+	 NOP_EXPR,
 	 UNKNOWN_LOCATION, build_int_cst (TREE_TYPE (rhs_var[ii]), 0),
 	 TREE_TYPE (rhs_var[ii]));
     }
   
 
-  for (ii = 0; ii < lhs_rank ; ii++)
+  for (ii = 0; ii < max (lhs_rank, rhs_rank); ii++)
     {
       /* this will create the if statement label */
       if_stmt_label[ii] = build_decl (UNKNOWN_LOCATION, LABEL_DECL, NULL_TREE,
@@ -530,12 +557,14 @@ build_x_array_notation_expr (tree lhs, enum tree_code modifycode, tree rhs,
 	 build2 (PLUS_EXPR, TREE_TYPE (rhs_var[ii]), rhs_var[ii],
 		 build_int_cst (TREE_TYPE (rhs_var[ii]), 1)));
     }
-      
-
+  
+  if (!array_expr_lhs)
+    array_expr_lhs = lhs;
+  
   array_expr = build_x_modify_expr (array_expr_lhs, modifycode, array_expr_rhs,
 				    complain);
 
-  for (jj = 0; jj < lhs_rank; jj++)
+  for (jj = 0; jj < max (lhs_rank, rhs_rank); jj++)
     {
       if (rhs_rank && rhs_expr_incr[jj])
 	{
@@ -563,9 +592,12 @@ build_x_array_notation_expr (tree lhs, enum tree_code modifycode, tree rhs,
 	  else
 	    rhs_compare[jj] = build2 (LT_EXPR, boolean_type_node, rhs_var[jj],
 				      rhs_length[0][jj]);
-      
-	  cond_expr[jj] = build2 (TRUTH_ANDIF_EXPR, void_type_node,
-				  lhs_compare[jj], rhs_compare[jj]);
+
+	  if (lhs_rank)
+	    cond_expr[jj] = build2 (TRUTH_ANDIF_EXPR, void_type_node,
+				    lhs_compare[jj], rhs_compare[jj]);
+	  else
+	    cond_expr[jj] = rhs_compare[jj];
 	}
       else
 	{
@@ -594,9 +626,10 @@ build_x_array_notation_expr (tree lhs, enum tree_code modifycode, tree rhs,
    */
 
   
-  for (ii = 0; ii < lhs_rank; ii++)
+  for (ii = 0; ii < max (lhs_rank, rhs_rank); ii++)
     {
-      append_to_statement_list (lhs_ind_init [ii], &loop);
+      if (lhs_rank)
+	append_to_statement_list (lhs_ind_init [ii], &loop);
       if (rhs_rank)
 	append_to_statement_list (rhs_ind_init[ii], &loop);
       append_to_statement_list (build1 (LABEL_EXPR, void_type_node,
@@ -608,12 +641,14 @@ build_x_array_notation_expr (tree lhs, enum tree_code modifycode, tree rhs,
 
       append_to_statement_list (body_label_expr[ii], &loop);
     }
-  
-  append_to_statement_list (array_expr, &loop);
 
-  for (ii = lhs_rank - 1; ii >= 0; ii--)
+  if (max (lhs_rank, rhs_rank))
+    append_to_statement_list (array_expr, &loop);
+  
+  for (ii = max (lhs_rank, rhs_rank) - 1; ii >= 0; ii--)
     {
-      append_to_statement_list (lhs_expr_incr[ii], &loop);
+      if (lhs_rank)
+	append_to_statement_list (lhs_expr_incr[ii], &loop);
       if (rhs_rank && rhs_expr_incr[ii])
 	append_to_statement_list (rhs_expr_incr[ii], &loop);
   
@@ -914,7 +949,7 @@ fix_conditional_array_notations_1 (tree stmt)
  * also walk through their subtrees.
  */
 tree
-fix_conditional_array_notations (tree t)
+fix_array_notation_exprs (tree t)
 {
   enum tree_code code;
   bool is_expr;
@@ -949,10 +984,6 @@ fix_conditional_array_notations (tree t)
     case NOP_EXPR:
     case INIT_EXPR:
     case MODIFY_EXPR:
-    case PREDECREMENT_EXPR:
-    case PREINCREMENT_EXPR:
-    case POSTDECREMENT_EXPR:
-    case POSTINCREMENT_EXPR:
     case ADDR_EXPR:
     case ARRAY_REF:
     case BIT_FIELD_REF:
@@ -965,7 +996,7 @@ fix_conditional_array_notations (tree t)
     case BIND_EXPR:
       {
 	BIND_EXPR_BODY (t) =
-	  fix_conditional_array_notations  (BIND_EXPR_BODY (t));
+	  fix_array_notation_exprs  (BIND_EXPR_BODY (t));
 	return t;
       }
 
@@ -974,7 +1005,7 @@ fix_conditional_array_notations (tree t)
 	tree_stmt_iterator i;
 	for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
 	  *tsi_stmt_ptr (i) =
-	    fix_conditional_array_notations (*tsi_stmt_ptr (i));
+	    fix_array_notation_exprs (*tsi_stmt_ptr (i));
 	return t;
       }
 
@@ -999,29 +1030,37 @@ fix_conditional_array_notations (tree t)
     case ARRAY_TYPE:
     case RECORD_TYPE:
     case METHOD_TYPE:
+      return t;
+ 
+    case PREDECREMENT_EXPR:
+    case PREINCREMENT_EXPR:
+    case POSTDECREMENT_EXPR:
+    case POSTINCREMENT_EXPR:
     case AGGR_INIT_EXPR:
     case CALL_EXPR:
+    case CLEANUP_POINT_EXPR:
+    case EXPR_STMT:
+      t = fix_unary_array_notation_exprs (t);
       return t;
-
     case COND_EXPR:
       t = fix_conditional_array_notations_1 (t);
       if (TREE_CODE (t) == COND_EXPR)
 	{
 	  COND_EXPR_THEN (t) =
-	    fix_conditional_array_notations (COND_EXPR_THEN (t));
+	    fix_array_notation_exprs (COND_EXPR_THEN (t));
 	  COND_EXPR_ELSE (t) =
-	    fix_conditional_array_notations (COND_EXPR_ELSE (t));
+	    fix_array_notation_exprs (COND_EXPR_ELSE (t));
 	}
       else
-	t = fix_conditional_array_notations (t);
+	t = fix_array_notation_exprs (t);
       return t;
 
     case SWITCH_EXPR:
       t = fix_conditional_array_notations_1 (t);
       if (TREE_CODE (t) == SWITCH_EXPR)
-	SWITCH_BODY (t) = fix_conditional_array_notations (SWITCH_BODY (t));
+	SWITCH_BODY (t) = fix_array_notation_exprs (SWITCH_BODY (t));
       else
-	t = fix_conditional_array_notations (t);
+	t = fix_array_notation_exprs (t);
       return t;
       
     case FOR_STMT:
@@ -1032,9 +1071,9 @@ fix_conditional_array_notations (tree t)
        * for statement, then we can't assume it is still FOR_STMT/CILK_FOR_STMT
        * so we have to check again */
       if (TREE_CODE (t) == CILK_FOR_STMT || TREE_CODE (t) == FOR_STMT)
-	FOR_BODY (t) = fix_conditional_array_notations (FOR_BODY (t));
+	FOR_BODY (t) = fix_array_notation_exprs (FOR_BODY (t));
       else
-	t = fix_conditional_array_notations (t);
+	t = fix_array_notation_exprs (t);
       return t;
 
     case IF_STMT:
@@ -1045,12 +1084,12 @@ fix_conditional_array_notations (tree t)
       if (TREE_CODE (t) == IF_STMT)
 	{
 	  if (THEN_CLAUSE (t))
-	    THEN_CLAUSE (t) = fix_conditional_array_notations (THEN_CLAUSE (t));
+	    THEN_CLAUSE (t) = fix_array_notation_exprs (THEN_CLAUSE (t));
 	  if (ELSE_CLAUSE (t))
-	    ELSE_CLAUSE (t) = fix_conditional_array_notations (ELSE_CLAUSE (t));
+	    ELSE_CLAUSE (t) = fix_array_notation_exprs (ELSE_CLAUSE (t));
 	}
       else
-	t = fix_conditional_array_notations (t);
+	t = fix_array_notation_exprs (t);
       return t;
 
     case SWITCH_STMT:
@@ -1062,10 +1101,10 @@ fix_conditional_array_notations (tree t)
 	{
 	  if (SWITCH_STMT_BODY (t))
 	    SWITCH_STMT_BODY (t) =
-	      fix_conditional_array_notations (SWITCH_STMT_BODY (t));
+	      fix_array_notation_exprs (SWITCH_STMT_BODY (t));
 	}
       else
-	t = fix_conditional_array_notations (t);
+	t = fix_array_notation_exprs (t);
       return t;
 
     case WHILE_STMT:
@@ -1076,10 +1115,10 @@ fix_conditional_array_notations (tree t)
       if (TREE_CODE (t) == WHILE_STMT)
 	{
 	  if (WHILE_BODY (t))
-	    WHILE_BODY (t) = fix_conditional_array_notations (WHILE_BODY (t));
+	    WHILE_BODY (t) = fix_array_notation_exprs (WHILE_BODY (t));
 	}
       else
-	t = fix_conditional_array_notations (t);
+	t = fix_array_notation_exprs (t);
       return t;
       
     case DO_STMT:
@@ -1090,10 +1129,10 @@ fix_conditional_array_notations (tree t)
       if (TREE_CODE (t) == DO_STMT)
 	{      
 	  if (DO_BODY (t))
-	    DO_BODY (t) = fix_conditional_array_notations (DO_BODY (t));
+	    DO_BODY (t) = fix_array_notation_exprs (DO_BODY (t));
 	}
       else
-	t = fix_conditional_array_notations (t);
+	t = fix_array_notation_exprs (t);
       return t;
       
     default:
@@ -1108,9 +1147,272 @@ fix_conditional_array_notations (tree t)
 	     that the scope of a FOR_EXPR is handled properly.  */
 	  for (i = 0; i < len; ++i)
 	    TREE_OPERAND (t, i) =
-	      fix_conditional_array_notations (TREE_OPERAND (t, i));
+	      fix_array_notation_exprs (TREE_OPERAND (t, i));
 	}
       return t;
     }
   return t;
 }
+
+tree
+fix_unary_array_notation_exprs (tree stmt)
+{
+
+  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;
+  find_rank (stmt, &rank);
+  if (rank == 0)
+    return stmt;  
+  
+  extract_array_notation_exprs (stmt, &array_list, &list_size);
+  
+  if (*array_list == NULL_TREE || list_size == 0)
+    return stmt;
+
+  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 (&stmt, 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]);
+	}
+    }
+  
+  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 (stmt, &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);
+
+  stmt = loop;
+  return stmt;
+}
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index eae4550..4f3778d 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -6026,7 +6026,7 @@ extern void gimplify_cilk_spawn                (tree *, gimple_seq *,
 /* In cp/cp-array-notations.c */
 extern tree build_x_array_notation_expr        (tree, enum tree_code, tree,
 						tsubst_flags_t);
-extern tree fix_conditional_array_notations    (tree);
+extern tree fix_array_notation_exprs           (tree);
 /* -- end of C++ */
 
 #endif /* ! GCC_CP_TREE_H */
diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index 7f96acd..fd35211 100644
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -41,6 +41,8 @@ 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 tree fix_unary_array_notation_exprs (tree);
 struct pragma_simd_values local_simd_values;
 
 /* The lexer.  */
@@ -7636,6 +7638,7 @@ cp_parser_assignment_expression (cp_parser* parser, bool cast_p,
 				 cp_id_kind * pidk)
 {
   tree expr;
+  tree new_expr;
 
   /* If the next token is the `throw' keyword, then we're looking at
      a throw-expression.  */
@@ -7679,16 +7682,15 @@ cp_parser_assignment_expression (cp_parser* parser, bool cast_p,
 	      /* Check if expression is of type ARRAY_NOTATION_REF, if so then
 	       * break up an array notation expression correctly 
 	       */
-	      if (TREE_CODE (expr) == ARRAY_NOTATION_REF
-		  || TREE_CODE (rhs) == ARRAY_NOTATION_REF)
-		expr = build_x_array_notation_expr (expr, assignment_operator,
-						    rhs, tf_warning_or_error);
-	      else
-		/* Build the assignment expression.  */
+	      new_expr = build_x_array_notation_expr (expr, assignment_operator,
+						      rhs, tf_warning_or_error);
+	      if (!new_expr)
 		expr = build_x_modify_expr (expr,
 					    assignment_operator,
 					    rhs,
 					    tf_warning_or_error);
+	      else
+		expr = new_expr;
 	    }
 	}
     }
@@ -9121,7 +9123,8 @@ cp_parser_compound_statement (cp_parser *parser, tree in_statement_expr,
   /* Consume the `}'.  */
   cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
 
-  compound_stmt = fix_conditional_array_notations (compound_stmt);
+  if (flag_enable_cilk)
+    compound_stmt = fix_array_notation_exprs (compound_stmt);
   return compound_stmt;
 }
 
diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index 9de4d67..a0f0e92 100644
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -4863,9 +4863,17 @@ cp_build_addr_expr_1 (tree arg, bool strict_lvalue, tsubst_flags_t complain)
       cp_lvalue_kind kind = lvalue_kind (arg);
       if (kind == clk_none)
 	{
-	  if (complain & tf_error)
-	    lvalue_error (input_location, lv_addressof);
-	  return error_mark_node;
+	  /* If we are using array notation, we will fix it up at the end,
+	   * so right now, we just ignore this error
+	   */
+	  if (flag_enable_cilk && TREE_CODE (arg) == ARRAY_NOTATION_REF)
+	    ;
+	  else
+	    {
+	      if (complain & tf_error)
+		lvalue_error (input_location, lv_addressof);
+	      return error_mark_node;
+	    }
 	}
       if (strict_lvalue && (kind & (clk_rvalueref|clk_class)))
 	{
@@ -8423,7 +8431,12 @@ lvalue_or_else (tree ref, enum lvalue_use use, tsubst_flags_t complain)
 {
   cp_lvalue_kind kind = lvalue_kind (ref);
 
-  if (kind == clk_none)
+  if (flag_enable_cilk && TREE_CODE (ref) == ARRAY_NOTATION_REF)
+    /* IF we are using array notations then we will fix up later and not
+     * worry about it now
+     */
+    return 1;
+  else if (kind == clk_none)
     {
       if (complain & tf_error)
 	lvalue_error (input_location, use);
diff --git a/gcc/testsuite/ChangeLog.cilk b/gcc/testsuite/ChangeLog.cilk
index 80a004a..1071752 100644
--- a/gcc/testsuite/ChangeLog.cilk
+++ b/gcc/testsuite/ChangeLog.cilk
@@ -1,3 +1,13 @@
+2012-01-17  Balaji V. Iyer  <balaji.v.iyer@intel.com>
+
+	* g++.dg/cilk-plus/array_notation_tests/predecr_test.cc: New.
+	* g++.dg/cilk-plus/array_notation_tests/preincr_test.cc: Likewise.
+	* g++.dg/cilk-plus/array_notation_tests/postdecr_test.cc: Likewise.
+	* g++.dg/cilk-plus/array_notation_tests/postincr_test.cc: Likewise.
+	* g++.dg/cilk-plus/array_notation_tests/func.cc: Likewise.
+	* g++.dg/cilk-plus/array_notation_tests/func_call.cc: Likewise.
+	* g++.dg/cilk-plus/cilk-plus.exp: Added HAVE_IO flag for compilation.
+
 2012-01-12  Balaji V. Iyer  <balaji.v.iyer@intel.com>
 
 	* g++.dg/cilk-plus/array_notation_tests/switch_test.cc: New
diff --git a/gcc/testsuite/g++.dg/cilk-plus/array_notation_tests/postdecr_test.cc b/gcc/testsuite/g++.dg/cilk-plus/array_notation_tests/postdecr_test.cc
new file mode 100644
index 0000000..fc0955f
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cilk-plus/array_notation_tests/postdecr_test.cc
@@ -0,0 +1,47 @@
+#if HAVE_IO
+#include <iostream>
+#include <cstdlib>
+#endif
+using namespace std;
+int main(int argc, char **argv)
+{
+  int array[10];
+
+  for (int ii = 0; ii < 10; ii++)
+    array[ii] = 0;
+
+  array[:] = 19383;
+
+  array[:]--;
+
+#if HAVE_IO
+  for (int ii = 0; ii < 10; ii++)
+    cout << array[ii] << endl;
+  cout << endl;
+#endif
+
+  for (int ii = 0; ii < 10; ii++)
+    array[:]--;
+
+#if HAVE_IO
+  for (int ii = 0; ii < 10; ii++)
+    cout << array[ii] << endl;
+  cout << endl;
+#endif
+
+  if (argc == 2)
+    array[0:10:1]--; 
+
+#if HAVE_IO
+  for (int ii = 0; ii < 10; ii++)
+    cout << array[ii] << endl;
+  cout << endl;
+#endif
+  array[0:10/argc:argc]--; 
+
+#if HAVE_IO
+  for (int ii = 0; ii < 10; ii++)
+    cout << array[ii] << endl;
+#endif
+  return 1;
+}
diff --git a/gcc/testsuite/g++.dg/cilk-plus/array_notation_tests/postincr_test.cc b/gcc/testsuite/g++.dg/cilk-plus/array_notation_tests/postincr_test.cc
new file mode 100644
index 0000000..f6f0804
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cilk-plus/array_notation_tests/postincr_test.cc
@@ -0,0 +1,47 @@
+#if HAVE_IO
+#include <iostream>
+#include <cstdlib>
+#endif
+using namespace std;
+int main(int argc, char **argv)
+{
+  int array[10];
+
+  for (int ii = 0; ii < 10; ii++)
+    array[ii] = 0;
+
+  array[:] = 19383;
+
+  array[:]++;
+
+#if HAVE_IO
+  for (int ii = 0; ii < 10; ii++)
+    cout << array[ii] << endl;
+  cout << endl;
+#endif
+
+  for (int ii = 0; ii < 10; ii++)
+    array[:]++;
+
+#if HAVE_IO
+  for (int ii = 0; ii < 10; ii++)
+    cout << array[ii] << endl;
+  cout << endl;
+#endif
+
+  if (argc == 2)
+    array[0:10:1]++; 
+
+#if HAVE_IO
+  for (int ii = 0; ii < 10; ii++)
+    cout << array[ii] << endl;
+  cout << endl;
+#endif
+  array[0:10/argc:argc]++; 
+
+#if HAVE_IO
+  for (int ii = 0; ii < 10; ii++)
+    cout << array[ii] << endl;
+#endif
+  return 1;
+}
diff --git a/gcc/testsuite/g++.dg/cilk-plus/array_notation_tests/predecr_test.cc b/gcc/testsuite/g++.dg/cilk-plus/array_notation_tests/predecr_test.cc
new file mode 100644
index 0000000..47696c7
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cilk-plus/array_notation_tests/predecr_test.cc
@@ -0,0 +1,47 @@
+#if HAVE_IO
+#include <iostream>
+#include <cstdlib>
+#endif
+using namespace std;
+int main(int argc, char **argv)
+{
+  int array[10];
+
+  for (int ii = 0; ii < 10; ii++)
+    array[ii] = 0;
+
+  array[:] = 19383;
+
+  --array[:];
+
+#if HAVE_IO
+  for (int ii = 0; ii < 10; ii++)
+    cout << array[ii] << endl;
+  cout << endl;
+#endif
+
+  for (int ii = 0; ii < 10; ii++)
+    --array[:];
+
+#if HAVE_IO
+  for (int ii = 0; ii < 10; ii++)
+    cout << array[ii] << endl;
+  cout << endl;
+#endif
+
+  if (argc == 2)
+    --array[0:10:1]; 
+
+#if HAVE_IO
+  for (int ii = 0; ii < 10; ii++)
+    cout << array[ii] << endl;
+  cout << endl;
+#endif
+  --array[0:10/argc:argc]; 
+
+#if HAVE_IO
+  for (int ii = 0; ii < 10; ii++)
+    cout << array[ii] << endl;
+#endif
+  return 1;
+}
diff --git a/gcc/testsuite/g++.dg/cilk-plus/array_notation_tests/preincr_test.cc b/gcc/testsuite/g++.dg/cilk-plus/array_notation_tests/preincr_test.cc
new file mode 100644
index 0000000..9a0b1fd
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cilk-plus/array_notation_tests/preincr_test.cc
@@ -0,0 +1,47 @@
+#if HAVE_IO
+#include <iostream>
+#include <cstdlib>
+#endif
+using namespace std;
+int main(int argc, char **argv)
+{
+  int array[10];
+
+  for (int ii = 0; ii < 10; ii++)
+    array[ii] = 0;
+
+  array[:] = 19383;
+
+  ++array[:];
+
+#if HAVE_IO
+  for (int ii = 0; ii < 10; ii++)
+    cout << array[ii] << endl;
+  cout << endl;
+#endif
+
+  for (int ii = 0; ii < 10; ii++)
+    ++array[:];
+
+#if HAVE_IO
+  for (int ii = 0; ii < 10; ii++)
+    cout << array[ii] << endl;
+  cout << endl;
+#endif
+
+  if (argc == 2)
+    ++array[0:10:1];
+
+#if HAVE_IO
+  for (int ii = 0; ii < 10; ii++)
+    cout << array[ii] << endl;
+  cout << endl;
+#endif
+  ++array[0:10/argc:argc]; 
+
+#if HAVE_IO
+  for (int ii = 0; ii < 10; ii++)
+    cout << array[ii] << endl;
+#endif
+  return 1;
+}
diff --git a/gcc/testsuite/g++.dg/cilk-plus/cilk_plus.exp b/gcc/testsuite/g++.dg/cilk-plus/cilk_plus.exp
index 1fa67ce..33f10ae 100644
--- a/gcc/testsuite/g++.dg/cilk-plus/cilk_plus.exp
+++ b/gcc/testsuite/g++.dg/cilk-plus/cilk_plus.exp
@@ -23,6 +23,6 @@ dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/*.cc]] " -w -lcilkrts -ldl -
 dg-finish
 
 dg-init
-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/array_notation_tests/*.cc]] " -O3 -ftree-vectorize" " "
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/array_notation_tests/*.cc]] " -DHAVE_IO=1 -O3 -ftree-vectorize" " "
 
 dg-finish
diff --git a/gcc/testsuite/g++.dg/cilk-plus/func.cc b/gcc/testsuite/g++.dg/cilk-plus/func.cc
new file mode 100644
index 0000000..97511e3
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cilk-plus/func.cc
@@ -0,0 +1,9 @@
+int funct (int x)
+{
+  x++;
+  return x;
+}
+int funct2 (int x, int y)
+{
+  return (x+y);
+}
diff --git a/gcc/testsuite/g++.dg/cilk-plus/func_call.cc b/gcc/testsuite/g++.dg/cilk-plus/func_call.cc
new file mode 100644
index 0000000..5a67f5c
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cilk-plus/func_call.cc
@@ -0,0 +1,100 @@
+#if HAVE_IO
+#include <iostream> 
+#endif
+
+extern int funct(int x);
+extern int funct2(int x, int y);
+extern void func_ptr (int *x);
+int main(int argc, char **argv)
+{
+  int array[10], array2[10], x = 0, y;
+  for (int ii = 0; ii < 10; ii++)
+    array[ii] = 0;
+
+  array[:]++;
+#if HAVE_IO
+  for (int ii = 0; ii < 10; ii++)
+    array[0:10:1]++;
+#endif
+
+#if HAVE_IO
+  std::cout << "Before Function Call" << std::endl;
+  for (int ii = 0; ii < 10; ii++)
+    std::cout << array[ii] << std::endl;
+#endif
+
+  array2[:] = funct(array[:]);
+  
+#if HAVE_IO
+  std::cout << std::endl;
+  std::cout << "After Function Call" << std::endl;
+  for (int ii = 0; ii < 10; ii++)
+    std::cout << array2[ii] << std::endl;
+#endif
+
+  x += funct (array[:]);
+#if HAVE_IO
+  std::cout << "x (Just sum of all in After Function Call) = " << x 
+    << std::endl;
+#endif
+
+  x = 0;
+  x += funct (array[0:10:1]);
+#if HAVE_IO
+  std::cout << "x (Just sum of all in After Function Call) = " << x 
+    << std::endl;
+#endif
+
+  x = 0;
+  x += funct (array[0:10/argc:argc]);
+#if HAVE_IO
+  std::cout << "x (Just sum of all in After Function Call, if Argc == 1) = " 
+    << x << std::endl;
+#endif
+
+  x = 0;
+#if HAVE_IO
+  x = funct (funct(array[:]));
+  std::cout << "x (Just array[9]+1+1) = " << x << std::endl;
+#endif
+  array2[:] = funct (funct (funct (array[:])));
+
+#if HAVE_IO
+  std::cout << "After Function Call (must be array[x]+1+1+1" << std::endl;
+  for (int ii = 0; ii < 10; ii++)
+    std::cout << array2[ii] << std::endl;
+#endif
+  x = 0;
+  for (int ii = 0; ii < 10; ii++) 
+    x += funct (funct (funct (array[:])));
+
+#if HAVE_IO
+  std::cout << "x  (After 3 function calls in for loop 14 * 100) =  " << x <<
+    std::endl;
+#endif
+  x = 0;
+  for (int ii = 0; ii < 10; ii++)
+    x += funct (funct (funct (funct2 (array[:], array2[:]))));
+
+#if HAVE_IO
+  std::cout << 
+    "x  (After 4 different function calls in for loop ((11+14)+3) * 100) =  " << x <<
+    std::endl;
+#endif
+
+#if HAVE_IO
+  std::cout << std::endl;
+  std::cout << "Before adding every element by 1" << std::endl;
+  for (int ii = 0; ii < 10; ii++)
+    std::cout << array[ii] << std::endl;
+#endif
+
+  func_ptr (&array[:]);
+#if HAVE_IO
+  std::cout << std::endl;
+  std::cout << "After adding every element by 1" << std::endl;
+  for (int ii = 0; ii < 10; ii++)
+    std::cout << array[ii] << std::endl;
+#endif
+  return x;
+}
