===================================================================
@@ -900,7 +900,7 @@ Common Report Var(align_functions,0) Optimization
Align the start of functions.
falign-functions=
-Common RejectNegative Joined UInteger Var(align_functions)
+Common RejectNegative Joined Var(flag_align_functions)
falign-jumps
Common Report Var(align_jumps,0) Optimization UInteger
@@ -907,7 +907,7 @@ Common Report Var(align_jumps,0) Optimization UInt
Align labels which are only reached by jumping.
falign-jumps=
-Common RejectNegative Joined UInteger Var(align_jumps)
+Common RejectNegative Joined Var(flag_align_jumps)
falign-labels
Common Report Var(align_labels,0) Optimization UInteger
@@ -914,7 +914,7 @@ Common Report Var(align_labels,0) Optimization UIn
Align all labels.
falign-labels=
-Common RejectNegative Joined UInteger Var(align_labels)
+Common RejectNegative Joined Var(flag_align_labels)
falign-loops
Common Report Var(align_loops,0) Optimization UInteger
@@ -921,7 +921,7 @@ Common Report Var(align_loops,0) Optimization UInt
Align the start of loops.
falign-loops=
-Common RejectNegative Joined UInteger Var(align_loops)
+Common RejectNegative Joined Var(flag_align_loops)
fargument-alias
Common Ignore
===================================================================
@@ -337,9 +337,10 @@ Objective-C and Objective-C++ Dialects}.
@item Optimization Options
@xref{Optimize Options,,Options that Control Optimization}.
-@gccoptlist{-faggressive-loop-optimizations -falign-functions[=@var{n}] @gol
--falign-jumps[=@var{n}] @gol
--falign-labels[=@var{n}] -falign-loops[=@var{n}] @gol
+@gccoptlist{-faggressive-loop-optimizations @gol
+-falign-functions[=@var{n}[,@var{m}]] @gol
+-falign-jumps[=@var{n}[,@var{m}]] @gol
+-falign-labels[=@var{n}[,@var{m}]] -falign-loops[=@var{n}[,@var{m}]] @gol
-fassociative-math -fauto-profile -fauto-profile[=@var{path}] @gol
-fauto-inc-dec -fbranch-probabilities @gol
-fbranch-target-load-optimize -fbranch-target-load-optimize2 @gol
@@ -7931,9 +7932,11 @@ The @option{-fstrict-overflow} option is enabled a
@item -falign-functions
@itemx -falign-functions=@var{n}
+@itemx -falign-functions=@var{n},@var{m}
@opindex falign-functions
+If @var{m} is not specified, it defaults to @var{n}.
Align the start of functions to the next power-of-two greater than
-@var{n}, skipping up to @var{n} bytes. For instance,
+@var{n}, skipping up to @var{m}-1 bytes. For instance,
@option{-falign-functions=32} aligns functions to the next 32-byte
boundary, but @option{-falign-functions=24} aligns to the next
32-byte boundary only if this can be done by skipping 23 bytes or less.
@@ -7950,9 +7953,11 @@ Enabled at levels @option{-O2}, @option{-O3}.
@item -falign-labels
@itemx -falign-labels=@var{n}
+@itemx -falign-labels=@var{n},@var{m}
@opindex falign-labels
+If @var{m} is not specified, it defaults to @var{n}.
Align all branch targets to a power-of-two boundary, skipping up to
-@var{n} bytes like @option{-falign-functions}. This option can easily
+@var{m}-1 bytes like @option{-falign-functions}. This option can easily
make code slower, because it must insert dummy operations for when the
branch target is reached in the usual flow of the code.
@@ -7969,8 +7974,10 @@ Enabled at levels @option{-O2}, @option{-O3}.
@item -falign-loops
@itemx -falign-loops=@var{n}
+@itemx -falign-loops=@var{n},@var{m}
@opindex falign-loops
-Align loops to a power-of-two boundary, skipping up to @var{n} bytes
+If @var{m} is not specified, it defaults to @var{n}.
+Align loops to a power-of-two boundary, skipping up to @var{m}-1 bytes
like @option{-falign-functions}. If the loops are
executed many times, this makes up for any execution of the dummy
operations.
@@ -7984,9 +7991,11 @@ Enabled at levels @option{-O2}, @option{-O3}.
@item -falign-jumps
@itemx -falign-jumps=@var{n}
+@itemx -falign-jumps=@var{n},@var{m}
@opindex falign-jumps
+If @var{m} is not specified, it defaults to @var{n}.
Align branch targets to a power-of-two boundary, for branch targets
-where the targets can only be reached by jumping, skipping up to @var{n}
+where the targets can only be reached by jumping, skipping up to @var{m}-1
bytes like @option{-falign-functions}. In this case, no dummy operations
need be executed.
===================================================================
@@ -55,6 +55,7 @@ struct target_flag_state {
int x_align_labels_log;
int x_align_labels_max_skip;
int x_align_functions_log;
+ int x_align_functions_max_skip;
/* The excess precision currently in effect. */
enum excess_precision x_flag_excess_precision;
@@ -81,6 +82,8 @@ extern struct target_flag_state *this_target_flag_
(this_target_flag_state->x_align_labels_max_skip)
#define align_functions_log \
(this_target_flag_state->x_align_functions_log)
+#define align_functions_max_skip \
+ (this_target_flag_state->x_align_functions_max_skip)
#define flag_excess_precision \
(this_target_flag_state->x_flag_excess_precision)
===================================================================
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -falign-functions=64,8" } */
+/* { dg-final { scan-assembler ".p2align 6,,7" } } */
+
+void
+test_func (void)
+{
+}
===================================================================
@@ -1177,29 +1177,58 @@ target_supports_section_anchors_p (void)
return true;
}
+static int
+parse_N_M (int *align, int *maxskip, const char *flag, const char *name)
+{
+ int _align = *align;
+ int _maxskip = *maxskip;
+
+ if (flag)
+ {
+ unsigned int n, m;
+ if (strchr (flag, ','))
+ {
+ if (sscanf (flag, "%u,%u", &n, &m) != 2) goto bad;
+ _maxskip = m;
+ }
+ else
+ {
+ if (sscanf (flag, "%u", &n) != 1) goto bad;
+ _maxskip = n;
+ }
+ _align = n;
+ if (_maxskip > 0)
+ _maxskip--; /* -falign-xyz=N,M means M-1 max bytes of padding, not M */
+ }
+
+normalize:
+ if (_align <= 0)
+ _align = 1;
+ if ((unsigned)_maxskip > (unsigned)_align)
+ _maxskip = _align - 1;
+
+ *align = _align;
+ *maxskip = _maxskip;
+ return floor_log2 (_align * 2 - 1);
+
+bad:
+ error_at (UNKNOWN_LOCATION, "-falign-%s parameter '%s' is bad", name, flag);
+ goto normalize;
+}
+
/* Default the align_* variables to 1 if they're still unset, and
set up the align_*_log variables. */
static void
init_alignments (void)
{
- if (align_loops <= 0)
- align_loops = 1;
- if (align_loops_max_skip > align_loops)
- align_loops_max_skip = align_loops - 1;
- align_loops_log = floor_log2 (align_loops * 2 - 1);
- if (align_jumps <= 0)
- align_jumps = 1;
- if (align_jumps_max_skip > align_jumps)
- align_jumps_max_skip = align_jumps - 1;
- align_jumps_log = floor_log2 (align_jumps * 2 - 1);
- if (align_labels <= 0)
- align_labels = 1;
- align_labels_log = floor_log2 (align_labels * 2 - 1);
- if (align_labels_max_skip > align_labels)
- align_labels_max_skip = align_labels - 1;
- if (align_functions <= 0)
- align_functions = 1;
- align_functions_log = floor_log2 (align_functions * 2 - 1);
+ align_loops_log = parse_N_M (&align_loops, &align_loops_max_skip,
+ flag_align_loops, "loops");
+ align_jumps_log = parse_N_M (&align_jumps, &align_jumps_max_skip,
+ flag_align_jumps, "jumps");
+ align_labels_log = parse_N_M (&align_labels, &align_labels_max_skip,
+ flag_align_labels, "labels");
+ align_functions_log = parse_N_M (&align_functions, &align_functions_max_skip,
+ flag_align_functions, "functions");
}
/* Process the options that have been parsed. */
===================================================================
@@ -1790,7 +1790,7 @@ assemble_start_function (tree decl, const char *fn
{
#ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file,
- align_functions_log, align_functions - 1);
+ align_functions_log, align_functions_max_skip);
#else
ASM_OUTPUT_ALIGN (asm_out_file, align_functions_log);
#endif