ipa-fnsummary.h (enum ipa_hints_vals): Fix comment typo, preffer -> prefer.

	* ipa-fnsummary.h (enum ipa_hints_vals): Fix comment typo,
	preffer -> prefer.
	* ipa-inline.c (edge_badness): Likewise.
	* lto-streamer.h (class lto_location_cache): Likewise.
	* tree-ssa-sink.c (select_best_block): Likewise.  Fix comment typos,
	gratutious -> gratuitous.

From-SVN: r278546

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index cfa7d61fb0997e2f36d0e68565fe1fd886c30add..e705e4a2e99f37db644757b11b590f8b337abf58 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,12 @@
+2019-11-21  Jakub Jelinek  <jakub@redhat.com>
+
+       * ipa-fnsummary.h (enum ipa_hints_vals): Fix comment typo,
+       preffer -> prefer.
+       * ipa-inline.c (edge_badness): Likewise.
+       * lto-streamer.h (class lto_location_cache): Likewise.
+       * tree-ssa-sink.c (select_best_block): Likewise.  Fix comment typos,
+       gratutious -> gratuitous.
+
 2019-11-21  Richard Biener  <rguenther@suse.de>
 
        Revert

diff --git a/gcc/ipa-fnsummary.h b/gcc/ipa-fnsummary.h
index a50978aacb8914e4c2e3bbc224055c452a7b71c9..ebd475b6d983e55d7e557755a5ef165f053b0712 100644 (file)
--- a/gcc/ipa-fnsummary.h
+++ b/gcc/ipa-fnsummary.h
@@ -25,7 +25,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "ipa-predicate.h"
 
 
-/* Hints are reasons why IPA heuristics should preffer specializing given
+/* Hints are reasons why IPA heuristics should prefer specializing given
    function.  They are represtented as bitmap of the following values.  */
 enum ipa_hints_vals {
   /* When specialization turns indirect call into a direct call,

diff --git a/gcc/ipa-inline.c b/gcc/ipa-inline.c
index 6da3e96b45df69d41dcfc8d02856198526e9bf85..3cd1779f380d2d2ac86e2c3f0b8e5d79d3302cb2 100644 (file)
--- a/gcc/ipa-inline.c
+++ b/gcc/ipa-inline.c
@@ -1265,7 +1265,7 @@ edge_badness (struct cgraph_edge *edge, bool dump)
        }
       if (overall_growth > 0)
         {
-         /* Strongly preffer functions with few callers that can be inlined
+         /* Strongly prefer functions with few callers that can be inlined
             fully.  The square root here leads to smaller binaries at average.
             Watch however for extreme cases and return to linear function
             when growth is large.  */

diff --git a/gcc/lto-streamer.h b/gcc/lto-streamer.h
index 067a6660d2f923307205b9d97250b16839aac2ec..7b712808bd57ecebe7d60d81ecbc534c010f8315 100644 (file)
--- a/gcc/lto-streamer.h
+++ b/gcc/lto-streamer.h
@@ -296,7 +296,7 @@ typedef void (lto_free_section_data_f) (struct lto_file_decl_data *,
                                        size_t);
 
 /* The location cache holds expanded locations for streamed in trees.
-   This is done to reduce memory usage of libcpp linemap that strongly preffers
+   This is done to reduce memory usage of libcpp linemap that strongly prefers
    locations to be inserted in the soruce order.  */
 
 class lto_location_cache

diff --git a/gcc/tree-ssa-sink.c b/gcc/tree-ssa-sink.c
index 9e210effcba7c84868a9f5e2f310e11dae8517a7..eebff65cb4656219152ae9287929db39000dee86 100644 (file)
--- a/gcc/tree-ssa-sink.c
+++ b/gcc/tree-ssa-sink.c
@@ -176,7 +176,7 @@ nearest_common_dominator_of_uses (def_operand_p def_p, bool *debug_stmts)
 
    If the resulting block is in a shallower loop nest, then use it.  Else
    only use the resulting block if it has significantly lower execution
-   frequency than EARLY_BB to avoid gratutious statement movement.  We
+   frequency than EARLY_BB to avoid gratuitous statement movement.  We
    consider statements with VOPS more desirable to move.
 
    This pass would obviously benefit from PDO as it utilizes block
@@ -223,9 +223,9 @@ select_best_block (basic_block early_bb,
     }
 
   /* If BEST_BB is at the same nesting level, then require it to have
-     significantly lower execution frequency to avoid gratutious movement.  */
+     significantly lower execution frequency to avoid gratuitous movement.  */
   if (bb_loop_depth (best_bb) == bb_loop_depth (early_bb)
-      /* If result of comparsion is unknown, preffer EARLY_BB.
+      /* If result of comparsion is unknown, prefer EARLY_BB.
         Thus use !(...>=..) rather than (...<...)  */
       && !(best_bb->count.apply_scale (100, 1)
           > (early_bb->count.apply_scale (threshold, 1))))