Add support and proper relocation of GCC loop pragmas [GH #174]

doc/source/code_style.rst

@@ -707,3 +707,16 @@ instead of:
 .. code:: cpp
 
    f(a, b, c, d, /*is_foo_bar=*/FALSE, /*needs_more_squirrels=*/VERY_FALSE);
+
+Wrapping Array Subscripts
+-------------------------
+
+Array subscripts that cause the line length to exceed 79 characters are
+wrapped like a function call whose argument cannot fit: the line is broken
+after the "``[``" and the continuation is right-aligned to column 79, including
+the closing "``]``" and any punctuation that follows it:
+
+.. code:: cpp
+
+   pkdp = pragma_description_for_pragma_kind[
+                     /* something very long (right-aligned to column 79) */];

doc/source/err_msgs.rst

@@ -10447,3 +10447,7 @@ Error Messages
    - | ``tag_redefined_differently``\ :
      | this declaration of *entity-kind "entity"*\  does not declare the
        same type as the declaration at line *xxxx*\ 
+ * - ``3600``\ 
+   - | ``bad_gcc_unroll_pragma_value``\ :
+     | the argument of "#pragma GCC unroll" must be a non-negative integral
+       constant less than 65535

src/cp_gen_be.c

@@ -20528,17 +20528,13 @@ Generate one of the predefined UPC pragmas.
 
 #endif /* UPC_EXTENSIONS_ALLOWED */
 
-static void gen_pragma(void)
+static void gen_pragma_entry(a_pragma_ptr pp)
 /*
-Generate a declaration for a pragma.  The current source sequence entry
-is the one associated with the pragma.
+Generate a declaration for the pragma pp.
 */
 {
-  a_pragma_ptr pp = ss_entry_ptr(curr_source_sequence_entry, a_pragma_ptr);
   a_boolean    saved_suppress_line_breaking = octl.suppress_line_breaking;
 
-  /* Advance past the source sequence entry for the pragma. */
-  adv_curr_source_sequence_entry();
   /* Ignore this entry if told to do so. */
   if (!pp->ignore_in_back_end) {
     octl.suppress_line_breaking = TRUE;
@@ -20612,9 +20608,66 @@ is the one associated with the pragma.
     }  /* if */
     octl.suppress_line_breaking = saved_suppress_line_breaking;
   }  /* if */
+}  /* gen_pragma_entry */
+
+
+static void gen_pragma(void)
+/*
+Generate a declaration for a pragma.  The current source sequence entry
+is the one associated with the pragma.
+*/
+{
+  a_pragma_ptr pp = ss_entry_ptr(curr_source_sequence_entry, a_pragma_ptr);
+
+  /* Advance past the source sequence entry for the pragma. */
+  adv_curr_source_sequence_entry();
+#if GNU_EXTENSIONS_ALLOWED
+  if (pp->kind == pk_gcc_next_statement) {
+    /* A GCC loop pragma (e.g., "#pragma GCC unroll") is generated in front
+       of the statement to which it is bound (see gen_gcc_statement_pragmas)
+       instead. */
+  } else
+#endif /* GNU_EXTENSIONS_ALLOWED */
+  /* Do not insert code here. */
+  {
+    gen_pragma_entry(pp);
+  }
 }  /* gen_pragma */
 
 
+#if GNU_EXTENSIONS_ALLOWED
+
+static void gen_gcc_statement_pragmas(a_statement_ptr statement)
+/*
+Generate any GCC loop pragmas (e.g., "#pragma GCC unroll") that are bound to
+the given statement.  These must be next to the statement (see
+gen_statement_full for their order relative to its attributes), so they are
+generated here rather than at their source sequence entries (see gen_pragma).
+*/
+{
+  if (!statement->has_associated_pragma) {
+    /* No pragmas are bound to the statement. */
+  } else if (innermost_function_scope == NULL ||
+             in_file_scope(statement)) {
+    /* The pragmas are on the list of a file or namespace scope, which
+       find_assoc_pragma locates through the front end's scope stack.  That
+       stack is no longer valid here. */
+  } else {
+    a_pragma_ptr pp = NULL;
+    while ((pp = find_assoc_pragma((char *)statement, iek_statement,
+                                   innermost_function_scope, pp)) != NULL) {
+      if (pp->kind == pk_gcc_next_statement) {
+        gen_pragma_entry(pp);
+        /* Resume the output at the position of the statement. */
+        set_output_position(&statement->position);
+      }  /* if */
+    }  /* while */
+  }  /* if */
+}  /* gen_gcc_statement_pragmas */
+
+#endif /* GNU_EXTENSIONS_ALLOWED */
+
+
 static void write_tok_str_if_nonnull(a_const_char *str)
 /*
 If str is NULL, do nothing.  Otherwise call write_tok_str(str).
@@ -22469,7 +22522,20 @@ one that yields the value) of a statement expression.
     /* Adjust the output position to match the statement position. */
     set_output_position(&statement->position);
   }  /* if */
+#if GNU_EXTENSIONS_ALLOWED
+  /* Generate any GCC loop pragmas bound to the statement.  Clang requires
+     them to precede the attributes of the loop, but GCC requires them to
+     follow those attributes (e.g., "[[likely]] #pragma GCC unroll 4 for"). */
+  if (clang_is_generated_code_target) {
+    gen_gcc_statement_pragmas(statement);
+  }  /* if */
+#endif /* GNU_EXTENSIONS_ALLOWED */
   gen_attributes(statement->attributes, al_prefix, /*primary_only=*/FALSE);
+#if GNU_EXTENSIONS_ALLOWED
+  if (!clang_is_generated_code_target) {
+    gen_gcc_statement_pragmas(statement);
+  }  /* if */
+#endif /* GNU_EXTENSIONS_ALLOWED */
   switch (kind) {
     case stmk_empty:
       write_tok_ch(';');

src/error_msg.txt

@@ -3679,5 +3679,6 @@ ec_exp_interpolator;;"expected an interpolator (\"\\[\", \"\\[:\", \"\\{\", \"\\
 ec_interpolated_id_is_not_identifier;;"%sq does not spell an identifier"
 ec_interpolated_operand_is_not_token_sequence;;"the operand of a \"\\{...}\" interpolator is not a token sequence"
 ec_tag_redefined_differently;;"this declaration of %n does not declare the same type as the declaration %p"
+ec_bad_gcc_unroll_pragma_value;;"the argument of \"#pragma GCC unroll\" must be a non-negative integral constant less than 65535"
  ###############################################################################
 

src/fe_init.c

@@ -259,6 +259,7 @@ CONSTINIT_ARRAY(/* none */, a_function_pointer, function_pointers, fn_last + 1)
 #endif /* SUN_EXTENSIONS_ALLOWED */
 #if GNU_EXTENSIONS_ALLOWED
   (a_function_pointer)gcc_pragma,
+  (a_function_pointer)gcc_next_statement_pragma,
 #if GNU_VECTOR_TYPES_ALLOWED && BUILTIN_FUNCTIONS_ENABLED
   (a_function_pointer)gnu_riscv_pragma,
   (a_function_pointer)clang_riscv_pragma,

src/il_alloc.c

@@ -4475,6 +4475,7 @@ pointer to it.
 #if GNU_EXTENSIONS_ALLOWED
     case pk_gcc_immediate:
     case pk_gcc_next_token:
+    case pk_gcc_next_statement:
       clear_gcc_pragma_descr(&pp->variant.gcc);
       break;
 #if GNU_VECTOR_TYPES_ALLOWED && BUILTIN_FUNCTIONS_ENABLED

src/il_def.h

@@ -6723,6 +6723,7 @@ enum a_pragma_kind : a_byte {
 #if GNU_EXTENSIONS_ALLOWED
   pk_gcc_immediate,     /* GCC pragmas (handled immediately). */
   pk_gcc_next_token,    /* GCC pragmas (handled as next token). */
+  pk_gcc_next_statement,/* GCC pragmas (bound to the next statement). */
 #if GNU_VECTOR_TYPES_ALLOWED && BUILTIN_FUNCTIONS_ENABLED
   pk_gnu_riscv,         /* GCC RISC-V intrinsics. */
   pk_clang_riscv,       /* Clang RISC-V intrinsics. */
@@ -6834,6 +6835,7 @@ EXTERN_CONSTINIT_ARRAY(a_const_char*, pragma_ids, pk_last + 1)
 #if GNU_EXTENSIONS_ALLOWED
 /* pk_gcc_immediate */		"GCC",
 /* pk_gcc_next_token */		"GCC",
+/* pk_gcc_next_statement */	"GCC",
 #if GNU_VECTOR_TYPES_ALLOWED && BUILTIN_FUNCTIONS_ENABLED
 /* pk_gnu_riscv */		"riscv",
 /* pk_clang_riscv */		"clang",

src/lower_c99.c

@@ -4483,10 +4483,15 @@ Do C99 lowering on an stmk_for statement.
     } else {
       /* The C99 case: move the initialization code out into a
          block surrounding the for loop.  Note that this is particularly
-         desirable when there is a VLA declaration in the initialization. */
+         desirable when there is a VLA declaration in the initialization.
+         Any pragmas attached to the for loop (e.g., "#pragma GCC unroll")
+         must stay with the for loop. */
       an_insert_location insert_location;
       flp->initialization = NULL;
-      turn_statement_into_block(for_stmt, &insert_location, &for_stmt);
+      turn_statement_into_block_transferring_pragma(for_stmt,
+                                                    &insert_location,
+                                                    &for_stmt,
+                                                    curr_context->scope);
       reinsert_for_loop_initialization(init_stmt, &insert_location);
     }  /* if */
   }  /* if */

src/lower_il.c

@@ -18407,7 +18407,7 @@ the try-block has been rewritten).
 }  /* put_block_around_try_block */
 
 
-static void turn_statement_into_block_transferring_pragma(
+void turn_statement_into_block_transferring_pragma(
                                         a_statement_ptr        statement,
                                         an_insert_location_ptr insert_location,
                                         a_statement_ptr        *orig_statement,
@@ -19763,9 +19763,12 @@ If the "for" statement has an associated "break" label, lower it also.
       break_label_stmt->next = NULL;
     }  /* if */
     /* Put a block statement around the for-loop and attach the scope
-       to that block. */
+       to that block.  Any pragmas attached to the for-loop (e.g., a
+       "#pragma GCC unroll") stay with the for-loop. */
     block_stmt = for_stmt;
-    turn_statement_into_block(for_stmt, &insert_location, &for_stmt);
+    turn_statement_into_block_transferring_pragma(for_stmt, &insert_location,
+                                                  &for_stmt,
+                                                  curr_context->scope);
     if (break_label_stmt != NULL) {
       /* Re-attach the break label after the "for" statement entry. */
       check_assertion(for_stmt->next == NULL);
@@ -19795,7 +19798,10 @@ If the "for" statement has an associated "break" label, lower it also.
       /* Put a block around the for loop if we didn't previously. */
       if (block_stmt == NULL) {
         block_stmt = for_stmt;
-        turn_statement_into_block(for_stmt, &insert_location, &for_stmt);
+        turn_statement_into_block_transferring_pragma(for_stmt,
+                                                      &insert_location,
+                                                      &for_stmt,
+                                                      curr_context->scope);
       }  /* if */
       reinsert_for_loop_initialization(init_stmt, &insert_location);
     }  /* if */
@@ -19895,11 +19901,14 @@ the following lowered C code is generated:
   push_context(&range_based_for_context, range_based_for_scope,
                (an_object_lifetime_ptr)NULL);
   /* Put a block statement around the range-based-for and attach the
-     range_based_for scope to that block.  Note that any pragmas attached to
-     the range-based-for statement will now be associated with the block. */
+     range_based_for scope to that block.  Any pragmas attached to the
+     range-based-for statement (e.g., a "#pragma GCC unroll") stay with the
+     statement, which becomes the lowered "for" loop. */
   outer_block = range_based_for_stmt;
-  turn_statement_into_block(range_based_for_stmt, &outer_insert_location,
-                            &range_based_for_stmt);
+  turn_statement_into_block_transferring_pragma(range_based_for_stmt,
+                                                &outer_insert_location,
+                                                &range_based_for_stmt,
+                                                curr_context->scope);
   outer_block->variant.block.extra_info->assoc_scope = range_based_for_scope;
   range_based_for_scope->assoc_block = outer_block;
   if (range_based_for_scope->lifetime != NULL) {

src/lower_il.h

@@ -1200,6 +1200,12 @@ extern void turn_statement_into_block(a_statement_ptr        statement,
                                       an_insert_location_ptr insert_location,
                                       a_statement_ptr        *orig_statement);
 
+extern void turn_statement_into_block_transferring_pragma(
+                                        a_statement_ptr        statement,
+                                        an_insert_location_ptr insert_location,
+                                        a_statement_ptr        *orig_statement,
+                                        a_scope_ptr            scope);
+
 extern void put_block_around_try_block(a_statement_ptr        statement,
                                        an_insert_location_ptr insert_location,
                                        a_statement_ptr        *orig_statement);

src/mem_manage.h

@@ -857,6 +857,7 @@ enum a_function_number : a_byte {
 #endif /* SUN_EXTENSIONS_ALLOWED */
 #if GNU_EXTENSIONS_ALLOWED
   fn_gcc_pragma,
+  fn_gcc_next_statement_pragma,
 #if GNU_VECTOR_TYPES_ALLOWED && BUILTIN_FUNCTIONS_ENABLED
   fn_gnu_riscv_pragma,
   fn_clang_riscv_pragma,

src/pending_changes/gh-174-gcc-loop-pragmas.txt

@@ -0,0 +1,47 @@
+//allowed_words: novector
+[GH #174]
+C- and C++-generating back ends: placement of GCC loop pragmas
+
+The GCC loop pragmas "#pragma GCC unroll", "#pragma GCC ivdep", and
+"#pragma GCC novector" were previously recorded in the IL as pragmas of the
+enclosing block and so were emitted by the C-generating back end at the start
+of that block, rather than immediately in front of the loop to which they
+apply.  The back-end compiler then rejected the generated code.  For example:
+
+  void h();
+  void f(char *first, char *last) {
+    h();
+  #pragma GCC unroll 4    // Previously emitted in front of the call of h,
+    while (first != last) // causing a "for, while or do statement expected"
+      ++first;            // error from the back-end compiler.
+  }
+
+In C99 and later modes, the C++-generating back end emitted such a pragma in
+front of the implicit block that surrounds an iteration statement, rather than
+in front of the loop inside it.  A loop pragma that followed an iteration or
+selection statement was emitted inside that statement's implicit block.  In
+both cases, the generated code could not be compiled.
+
+When the loop has attributes (e.g., "[[likely]]"), the C++-generating back
+end now emits the loop pragmas after those attributes when the generated code
+is for GCC, which requires a loop pragma to immediately precede the loop
+keyword, and before them when it is for Clang, which requires that order.
+
+The argument of "#pragma GCC unroll" is now scanned and evaluated as an
+integral constant expression, and its value replaces the original text in the
+generated code.  Previously, the argument was copied unchanged, so one that
+used C++ constructs or template parameters made the generated C code invalid.
+For example:
+
+  template<int N> void g(int *p) {
+  #pragma GCC unroll(N)                  // Now emitted as "unroll 4" in g<4>.
+    for (int i = 0; i < N; ++i) p[i] = 0;
+  }
+  void h(int *p) {
+  #pragma GCC unroll sizeof(decltype(0)) // Now emitted as "unroll 4".
+    for (int i = 0; i < 4; ++i) p[i] = 0;
+    g<4>(p);
+  }
+
+An argument that is negative or not less than 65535 is now diagnosed, as GCC
+does.

src/pragma.c

@@ -351,6 +351,7 @@ Construct a pending pragma with the given pragma kind description.
 #if GNU_EXTENSIONS_ALLOWED
     case pk_gcc_immediate:
     case pk_gcc_next_token:
+    case pk_gcc_next_statement:
       clear_gcc_pragma_descr(&this->variant.gcc);
       break;
 #if GNU_VECTOR_TYPES_ALLOWED && BUILTIN_FUNCTIONS_ENABLED
@@ -1857,11 +1858,30 @@ Initialize the pragma description table.
 #endif /* SUN_EXTENSIONS_ALLOWED */
 #if GNU_EXTENSIONS_ALLOWED
   if (gnu_mode && gnu_version >= 40200) {
-    /* "GCC" pragmas are handled by pk_gcc_next_token or pk_gcc_immediate
-       depending on the specific variety of "GCC" pragma.  Currently
-       "GCC diagnostic" pragmas are pk_gcc_next_token and all others are
-       pk_gcc_immediate.  Note that the order of these next two calls is
-       important (look_up_pragma_id relies on it). */
+    /* "GCC" pragmas are handled by pk_gcc_next_statement, pk_gcc_next_token,
+       or pk_gcc_immediate depending on the specific variety of "GCC" pragma.
+       Currently "GCC unroll", "GCC ivdep", and "GCC novector" pragmas
+       (which apply to the loop that follows them) are pk_gcc_next_statement,
+       "GCC diagnostic" pragmas are pk_gcc_next_token, and all others are
+       pk_gcc_immediate.  Note that the order of these next three calls is
+       important (look_up_pragma_id relies on it).  The pk_gcc_next_statement
+       pragmas are not automatically included in the IL because
+       gcc_next_statement_pragma may first need to rewrite the pragma text. */
+    (void)add_next_construct_pragma_kind_description
+                 ((a_pragma_kind)pk_gcc_next_statement,
+                 fn_for_function(gcc_next_statement_pragma),
+                 /*is_pseudo_pragma=*/FALSE,
+                 /*may_bind_to_decl=*/FALSE,
+                 /*may_bind_to_stmt=*/TRUE,
+                 /*automatically_include_in_il=*/FALSE,
+                 /*record_pragma_text=*/TRUE,
+                 /*expand_macros=*/FALSE,
+                 /*processing_C_code=*/TRUE,
+                 /*fetch_pp_tokens=*/FALSE,
+                 /*ignore_in_back_end=*/FALSE,
+                 /*il_info_is_complete=*/TRUE,
+                 /*read_string_as_header_name=*/FALSE,
+                 es_warning);
     (void)add_next_token_pragma_kind_description
                  ((a_pragma_kind)pk_gcc_next_token,
                  fn_for_function(gcc_pragma),