|
|
@@ -0,0 +1,826 @@
|
|
|
+From e5409aedd3ee2192855018a564650ffb75c26e60 Mon Sep 17 00:00:00 2001
|
|
|
+From: Max Filippov <jcmvbkbc@gmail.com>
|
|
|
+Date: Sun, 5 Apr 2015 17:04:22 +0300
|
|
|
+Subject: [PATCH 4/4] xtensa: replace action list with splay tree
|
|
|
+
|
|
|
+text_action_add uses linear list search to order text actions list by
|
|
|
+action VMA. The list is used at the first relaxation pass, when it's not
|
|
|
+fixed yet.
|
|
|
+Replace the list with splay tree from libiberty.
|
|
|
+
|
|
|
+Original profile:
|
|
|
+
|
|
|
+% time self children called name
|
|
|
+-----------------------------------------
|
|
|
+ 0.00 0.00 14/158225 compute_text_actions
|
|
|
+ 3.62 0.00 25211/158225 remove_dead_literal
|
|
|
+ 8.42 0.00 58645/158225 coalesce_shared_literal
|
|
|
+ 10.68 0.00 74355/158225 text_action_add_proposed
|
|
|
+ 38.8 22.73 0.00 158225 text_action_add
|
|
|
+ 0.00 0.00 144527/293246 bfd_zmalloc
|
|
|
+-----------------------------------------
|
|
|
+
|
|
|
+Same data, after optimization:
|
|
|
+
|
|
|
+% time self children called name
|
|
|
+-----------------------------------------
|
|
|
+ 0.00 0.00 14/158225 compute_text_actions
|
|
|
+ 0.00 0.00 25211/158225 remove_dead_literal
|
|
|
+ 0.00 0.01 58645/158225 coalesce_shared_literal
|
|
|
+ 0.00 0.01 74355/158225 text_action_add_proposed
|
|
|
+ 0.1 0.00 0.02 158225 text_action_add
|
|
|
+ 0.01 0.00 144527/144527 splay_tree_insert
|
|
|
+ 0.00 0.00 144527/195130 splay_tree_lookup
|
|
|
+ 0.00 0.00 144527/293246 bfd_zmalloc
|
|
|
+-----------------------------------------
|
|
|
+
|
|
|
+2015-04-03 Max Filippov <jcmvbkbc@gmail.com>
|
|
|
+bfd/
|
|
|
+ * elf32-xtensa.c (splay-tree.h): include header.
|
|
|
+ (text_action_struct): drop next pointer.
|
|
|
+ (text_action_list_struct): drop head pointer, add count and
|
|
|
+ tree fields.
|
|
|
+ (find_fill_action): instead of linear search in text_action_list
|
|
|
+ search in the tree.
|
|
|
+ (text_action_compare, action_first, action_next): new functions.
|
|
|
+ (text_action_add, text_action_add_literal): instead of linear
|
|
|
+ search and insertion insert new node into the tree.
|
|
|
+ (removed_by_actions): pass additional parameter: action_list,
|
|
|
+ use it to traverse the tree.
|
|
|
+ (offset_with_removed_text): pass additional action_list parameter
|
|
|
+ to removed_by_actions.
|
|
|
+ (map_action_fn_context): new typedef.
|
|
|
+ (map_action_fn_context_struct): new structure.
|
|
|
+ (map_action_fn): new function.
|
|
|
+ (map_removal_by_action): use splay_tree_foreach to build map.
|
|
|
+ (find_insn_action): replace linear search in text_action_list
|
|
|
+ with series of splay_tree_lookups.
|
|
|
+ (print_action, print_action_list_fn): new functions.
|
|
|
+ (print_action_list): use splay_tree_foreach.
|
|
|
+ (init_xtensa_relax_info): drop action_list.head initialization.
|
|
|
+ Initialize the tree.
|
|
|
+ (compute_text_actions): use non-zero action_list_count instead of
|
|
|
+ non-NULL action list.
|
|
|
+ (xlate_map_context): new typedef.
|
|
|
+ (xlate_map_context_struct): new structure.
|
|
|
+ (xlate_map_fn): new function.
|
|
|
+ (build_xlate_map): use splay_tree_foreach to build map.
|
|
|
+ (action_remove_bytes_fn): new function.
|
|
|
+ (relax_section): use zero action_list_count instead of NULL
|
|
|
+ action list. Use splay_tree_foreach to count final section size.
|
|
|
+ Drop unused variable 'removed'.
|
|
|
+
|
|
|
+Backported from: 4c2af04fe8b4452bf51d2debf1bb467fafcd0f08
|
|
|
+Signed-off-by: Max Filippov <jcmvbkbc@gmail.com>
|
|
|
+---
|
|
|
+ bfd/elf32-xtensa.c | 488 +++++++++++++++++++++++++++++++----------------------
|
|
|
+ 1 file changed, 282 insertions(+), 206 deletions(-)
|
|
|
+
|
|
|
+diff --git a/bfd/elf32-xtensa.c b/bfd/elf32-xtensa.c
|
|
|
+index 51733ad..53af1c6 100644
|
|
|
+--- a/bfd/elf32-xtensa.c
|
|
|
++++ b/bfd/elf32-xtensa.c
|
|
|
+@@ -28,6 +28,7 @@
|
|
|
+ #include "libbfd.h"
|
|
|
+ #include "elf-bfd.h"
|
|
|
+ #include "elf/xtensa.h"
|
|
|
++#include "splay-tree.h"
|
|
|
+ #include "xtensa-isa.h"
|
|
|
+ #include "xtensa-config.h"
|
|
|
+
|
|
|
+@@ -5416,8 +5417,6 @@ struct text_action_struct
|
|
|
+ bfd_vma virtual_offset; /* Zero except for adding literals. */
|
|
|
+ int removed_bytes;
|
|
|
+ literal_value value; /* Only valid when adding literals. */
|
|
|
+-
|
|
|
+- text_action *next;
|
|
|
+ };
|
|
|
+
|
|
|
+ struct removal_by_action_entry_struct
|
|
|
+@@ -5440,7 +5439,8 @@ typedef struct removal_by_action_map_struct removal_by_action_map;
|
|
|
+ /* List of all of the actions taken on a text section. */
|
|
|
+ struct text_action_list_struct
|
|
|
+ {
|
|
|
+- text_action *head;
|
|
|
++ unsigned count;
|
|
|
++ splay_tree tree;
|
|
|
+ removal_by_action_map map;
|
|
|
+ };
|
|
|
+
|
|
|
+@@ -5448,20 +5448,18 @@ struct text_action_list_struct
|
|
|
+ static text_action *
|
|
|
+ find_fill_action (text_action_list *l, asection *sec, bfd_vma offset)
|
|
|
+ {
|
|
|
+- text_action **m_p;
|
|
|
++ text_action a;
|
|
|
+
|
|
|
+ /* It is not necessary to fill at the end of a section. */
|
|
|
+ if (sec->size == offset)
|
|
|
+ return NULL;
|
|
|
+
|
|
|
+- for (m_p = &l->head; *m_p && (*m_p)->offset <= offset; m_p = &(*m_p)->next)
|
|
|
+- {
|
|
|
+- text_action *t = *m_p;
|
|
|
+- /* When the action is another fill at the same address,
|
|
|
+- just increase the size. */
|
|
|
+- if (t->offset == offset && t->action == ta_fill)
|
|
|
+- return t;
|
|
|
+- }
|
|
|
++ a.offset = offset;
|
|
|
++ a.action = ta_fill;
|
|
|
++
|
|
|
++ splay_tree_node node = splay_tree_lookup (l->tree, (splay_tree_key)&a);
|
|
|
++ if (node)
|
|
|
++ return (text_action *)node->value;
|
|
|
+ return NULL;
|
|
|
+ }
|
|
|
+
|
|
|
+@@ -5509,6 +5507,49 @@ adjust_fill_action (text_action *ta, int fill_diff)
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
++static int
|
|
|
++text_action_compare (splay_tree_key a, splay_tree_key b)
|
|
|
++{
|
|
|
++ text_action *pa = (text_action *)a;
|
|
|
++ text_action *pb = (text_action *)b;
|
|
|
++ static const int action_priority[] =
|
|
|
++ {
|
|
|
++ [ta_fill] = 0,
|
|
|
++ [ta_none] = 1,
|
|
|
++ [ta_convert_longcall] = 2,
|
|
|
++ [ta_narrow_insn] = 3,
|
|
|
++ [ta_remove_insn] = 4,
|
|
|
++ [ta_remove_longcall] = 5,
|
|
|
++ [ta_remove_literal] = 6,
|
|
|
++ [ta_widen_insn] = 7,
|
|
|
++ [ta_add_literal] = 8,
|
|
|
++ };
|
|
|
++
|
|
|
++ if (pa->offset == pb->offset)
|
|
|
++ {
|
|
|
++ if (pa->action == pb->action)
|
|
|
++ return 0;
|
|
|
++ return action_priority[pa->action] - action_priority[pb->action];
|
|
|
++ }
|
|
|
++ else
|
|
|
++ return pa->offset < pb->offset ? -1 : 1;
|
|
|
++}
|
|
|
++
|
|
|
++static text_action *
|
|
|
++action_first (text_action_list *action_list)
|
|
|
++{
|
|
|
++ splay_tree_node node = splay_tree_min (action_list->tree);
|
|
|
++ return node ? (text_action *)node->value : NULL;
|
|
|
++}
|
|
|
++
|
|
|
++static text_action *
|
|
|
++action_next (text_action_list *action_list, text_action *action)
|
|
|
++{
|
|
|
++ splay_tree_node node = splay_tree_successor (action_list->tree,
|
|
|
++ (splay_tree_key)action);
|
|
|
++ return node ? (text_action *)node->value : NULL;
|
|
|
++}
|
|
|
++
|
|
|
+ /* Add a modification action to the text. For the case of adding or
|
|
|
+ removing space, modify any current fill and assume that
|
|
|
+ "unreachable_space" bytes can be freely contracted. Note that a
|
|
|
+@@ -5521,8 +5562,8 @@ text_action_add (text_action_list *l,
|
|
|
+ bfd_vma offset,
|
|
|
+ int removed)
|
|
|
+ {
|
|
|
+- text_action **m_p;
|
|
|
+ text_action *ta;
|
|
|
++ text_action a;
|
|
|
+
|
|
|
+ /* It is not necessary to fill at the end of a section. */
|
|
|
+ if (action == ta_fill && sec->size == offset)
|
|
|
+@@ -5532,34 +5573,30 @@ text_action_add (text_action_list *l,
|
|
|
+ if (action == ta_fill && removed == 0)
|
|
|
+ return;
|
|
|
+
|
|
|
+- for (m_p = &l->head; *m_p && (*m_p)->offset <= offset; m_p = &(*m_p)->next)
|
|
|
++ a.action = action;
|
|
|
++ a.offset = offset;
|
|
|
++
|
|
|
++ if (action == ta_fill)
|
|
|
+ {
|
|
|
+- text_action *t = *m_p;
|
|
|
++ splay_tree_node node = splay_tree_lookup (l->tree, (splay_tree_key)&a);
|
|
|
+
|
|
|
+- if (action == ta_fill)
|
|
|
++ if (node)
|
|
|
+ {
|
|
|
+- /* When the action is another fill at the same address,
|
|
|
+- just increase the size. */
|
|
|
+- if (t->offset == offset && t->action == ta_fill)
|
|
|
+- {
|
|
|
+- t->removed_bytes += removed;
|
|
|
+- return;
|
|
|
+- }
|
|
|
+- /* Fills need to happen before widens so that we don't
|
|
|
+- insert fill bytes into the instruction stream. */
|
|
|
+- if (t->offset == offset && t->action == ta_widen_insn)
|
|
|
+- break;
|
|
|
++ ta = (text_action *)node->value;
|
|
|
++ ta->removed_bytes += removed;
|
|
|
++ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
++ else
|
|
|
++ BFD_ASSERT (splay_tree_lookup (l->tree, (splay_tree_key)&a) == NULL);
|
|
|
+
|
|
|
+- /* Create a new record and fill it up. */
|
|
|
+ ta = (text_action *) bfd_zmalloc (sizeof (text_action));
|
|
|
+ ta->action = action;
|
|
|
+ ta->sec = sec;
|
|
|
+ ta->offset = offset;
|
|
|
+ ta->removed_bytes = removed;
|
|
|
+- ta->next = (*m_p);
|
|
|
+- *m_p = ta;
|
|
|
++ splay_tree_insert (l->tree, (splay_tree_key)ta, (splay_tree_value)ta);
|
|
|
++ ++l->count;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+@@ -5570,7 +5607,6 @@ text_action_add_literal (text_action_list *l,
|
|
|
+ const literal_value *value,
|
|
|
+ int removed)
|
|
|
+ {
|
|
|
+- text_action **m_p;
|
|
|
+ text_action *ta;
|
|
|
+ asection *sec = r_reloc_get_section (loc);
|
|
|
+ bfd_vma offset = loc->target_offset;
|
|
|
+@@ -5578,14 +5614,6 @@ text_action_add_literal (text_action_list *l,
|
|
|
+
|
|
|
+ BFD_ASSERT (action == ta_add_literal);
|
|
|
+
|
|
|
+- for (m_p = &l->head; *m_p != NULL; m_p = &(*m_p)->next)
|
|
|
+- {
|
|
|
+- if ((*m_p)->offset > offset
|
|
|
+- && ((*m_p)->offset != offset
|
|
|
+- || (*m_p)->virtual_offset > virtual_offset))
|
|
|
+- break;
|
|
|
+- }
|
|
|
+-
|
|
|
+ /* Create a new record and fill it up. */
|
|
|
+ ta = (text_action *) bfd_zmalloc (sizeof (text_action));
|
|
|
+ ta->action = action;
|
|
|
+@@ -5594,8 +5622,10 @@ text_action_add_literal (text_action_list *l,
|
|
|
+ ta->virtual_offset = virtual_offset;
|
|
|
+ ta->value = *value;
|
|
|
+ ta->removed_bytes = removed;
|
|
|
+- ta->next = (*m_p);
|
|
|
+- *m_p = ta;
|
|
|
++
|
|
|
++ BFD_ASSERT (splay_tree_lookup (l->tree, (splay_tree_key)ta) == NULL);
|
|
|
++ splay_tree_insert (l->tree, (splay_tree_key)ta, (splay_tree_value)ta);
|
|
|
++ ++l->count;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+@@ -5606,7 +5636,8 @@ text_action_add_literal (text_action_list *l,
|
|
|
+ so that each search may begin where the previous one left off. */
|
|
|
+
|
|
|
+ static int
|
|
|
+-removed_by_actions (text_action **p_start_action,
|
|
|
++removed_by_actions (text_action_list *action_list,
|
|
|
++ text_action **p_start_action,
|
|
|
+ bfd_vma offset,
|
|
|
+ bfd_boolean before_fill)
|
|
|
+ {
|
|
|
+@@ -5614,6 +5645,13 @@ removed_by_actions (text_action **p_start_action,
|
|
|
+ int removed = 0;
|
|
|
+
|
|
|
+ r = *p_start_action;
|
|
|
++ if (r)
|
|
|
++ {
|
|
|
++ splay_tree_node node = splay_tree_lookup (action_list->tree,
|
|
|
++ (splay_tree_key)r);
|
|
|
++ BFD_ASSERT (node != NULL && r == (text_action *)node->value);
|
|
|
++ }
|
|
|
++
|
|
|
+ while (r)
|
|
|
+ {
|
|
|
+ if (r->offset > offset)
|
|
|
+@@ -5625,7 +5663,7 @@ removed_by_actions (text_action **p_start_action,
|
|
|
+
|
|
|
+ removed += r->removed_bytes;
|
|
|
+
|
|
|
+- r = r->next;
|
|
|
++ r = action_next (action_list, r);
|
|
|
+ }
|
|
|
+
|
|
|
+ *p_start_action = r;
|
|
|
+@@ -5636,68 +5674,74 @@ removed_by_actions (text_action **p_start_action,
|
|
|
+ static bfd_vma
|
|
|
+ offset_with_removed_text (text_action_list *action_list, bfd_vma offset)
|
|
|
+ {
|
|
|
+- text_action *r = action_list->head;
|
|
|
+- return offset - removed_by_actions (&r, offset, FALSE);
|
|
|
++ text_action *r = action_first (action_list);
|
|
|
++
|
|
|
++ return offset - removed_by_actions (action_list, &r, offset, FALSE);
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ static unsigned
|
|
|
+ action_list_count (text_action_list *action_list)
|
|
|
+ {
|
|
|
+- text_action *r = action_list->head;
|
|
|
+- unsigned count = 0;
|
|
|
+- for (r = action_list->head; r != NULL; r = r->next)
|
|
|
+- {
|
|
|
+- count++;
|
|
|
+- }
|
|
|
+- return count;
|
|
|
++ return action_list->count;
|
|
|
+ }
|
|
|
+
|
|
|
+-static void
|
|
|
+-map_removal_by_action (text_action_list *action_list)
|
|
|
++typedef struct map_action_fn_context_struct map_action_fn_context;
|
|
|
++struct map_action_fn_context_struct
|
|
|
+ {
|
|
|
+- text_action *r;
|
|
|
+- int removed = 0;
|
|
|
++ int removed;
|
|
|
+ removal_by_action_map map;
|
|
|
+ bfd_boolean eq_complete;
|
|
|
++};
|
|
|
+
|
|
|
+- map.n_entries = 0;
|
|
|
+- map.entry = bfd_malloc (action_list_count (action_list) *
|
|
|
+- sizeof (removal_by_action_entry));
|
|
|
+- eq_complete = FALSE;
|
|
|
++static int
|
|
|
++map_action_fn (splay_tree_node node, void *p)
|
|
|
++{
|
|
|
++ map_action_fn_context *ctx = p;
|
|
|
++ text_action *r = (text_action *)node->value;
|
|
|
++ removal_by_action_entry *ientry = ctx->map.entry + ctx->map.n_entries;
|
|
|
+
|
|
|
+- for (r = action_list->head; r;)
|
|
|
++ if (ctx->map.n_entries && (ientry - 1)->offset == r->offset)
|
|
|
+ {
|
|
|
+- removal_by_action_entry *ientry = map.entry + map.n_entries;
|
|
|
++ --ientry;
|
|
|
++ }
|
|
|
++ else
|
|
|
++ {
|
|
|
++ ++ctx->map.n_entries;
|
|
|
++ ctx->eq_complete = FALSE;
|
|
|
++ ientry->offset = r->offset;
|
|
|
++ ientry->eq_removed_before_fill = ctx->removed;
|
|
|
++ }
|
|
|
+
|
|
|
+- if (map.n_entries && (ientry - 1)->offset == r->offset)
|
|
|
++ if (!ctx->eq_complete)
|
|
|
++ {
|
|
|
++ if (r->action != ta_fill || r->removed_bytes >= 0)
|
|
|
+ {
|
|
|
+- --ientry;
|
|
|
++ ientry->eq_removed = ctx->removed;
|
|
|
++ ctx->eq_complete = TRUE;
|
|
|
+ }
|
|
|
+ else
|
|
|
+- {
|
|
|
+- ++map.n_entries;
|
|
|
+- eq_complete = FALSE;
|
|
|
+- ientry->offset = r->offset;
|
|
|
+- ientry->eq_removed_before_fill = removed;
|
|
|
+- }
|
|
|
++ ientry->eq_removed = ctx->removed + r->removed_bytes;
|
|
|
++ }
|
|
|
+
|
|
|
+- if (!eq_complete)
|
|
|
+- {
|
|
|
+- if (r->action != ta_fill || r->removed_bytes >= 0)
|
|
|
+- {
|
|
|
+- ientry->eq_removed = removed;
|
|
|
+- eq_complete = TRUE;
|
|
|
+- }
|
|
|
+- else
|
|
|
+- ientry->eq_removed = removed + r->removed_bytes;
|
|
|
+- }
|
|
|
++ ctx->removed += r->removed_bytes;
|
|
|
++ ientry->removed = ctx->removed;
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+
|
|
|
+- removed += r->removed_bytes;
|
|
|
+- ientry->removed = removed;
|
|
|
+- r = r->next;
|
|
|
+- }
|
|
|
+- action_list->map = map;
|
|
|
++static void
|
|
|
++map_removal_by_action (text_action_list *action_list)
|
|
|
++{
|
|
|
++ map_action_fn_context ctx;
|
|
|
++
|
|
|
++ ctx.removed = 0;
|
|
|
++ ctx.map.n_entries = 0;
|
|
|
++ ctx.map.entry = bfd_malloc (action_list_count (action_list) *
|
|
|
++ sizeof (removal_by_action_entry));
|
|
|
++ ctx.eq_complete = FALSE;
|
|
|
++
|
|
|
++ splay_tree_foreach (action_list->tree, map_action_fn, &ctx);
|
|
|
++ action_list->map = ctx.map;
|
|
|
+ }
|
|
|
+
|
|
|
+ static int
|
|
|
+@@ -5754,28 +5798,26 @@ offset_with_removed_text_map (text_action_list *action_list, bfd_vma offset)
|
|
|
+ static text_action *
|
|
|
+ find_insn_action (text_action_list *action_list, bfd_vma offset)
|
|
|
+ {
|
|
|
+- text_action *t;
|
|
|
+- for (t = action_list->head; t; t = t->next)
|
|
|
++ static const text_action_t action[] =
|
|
|
+ {
|
|
|
+- if (t->offset == offset)
|
|
|
+- {
|
|
|
+- switch (t->action)
|
|
|
+- {
|
|
|
+- case ta_none:
|
|
|
+- case ta_fill:
|
|
|
+- break;
|
|
|
+- case ta_remove_insn:
|
|
|
+- case ta_remove_longcall:
|
|
|
+- case ta_convert_longcall:
|
|
|
+- case ta_narrow_insn:
|
|
|
+- case ta_widen_insn:
|
|
|
+- return t;
|
|
|
+- case ta_remove_literal:
|
|
|
+- case ta_add_literal:
|
|
|
+- BFD_ASSERT (0);
|
|
|
+- break;
|
|
|
+- }
|
|
|
+- }
|
|
|
++ ta_convert_longcall,
|
|
|
++ ta_remove_longcall,
|
|
|
++ ta_widen_insn,
|
|
|
++ ta_narrow_insn,
|
|
|
++ ta_remove_insn,
|
|
|
++ };
|
|
|
++ text_action a;
|
|
|
++ unsigned i;
|
|
|
++
|
|
|
++ a.offset = offset;
|
|
|
++ for (i = 0; i < sizeof (action) / sizeof (*action); ++i)
|
|
|
++ {
|
|
|
++ splay_tree_node node;
|
|
|
++
|
|
|
++ a.action = action[i];
|
|
|
++ node = splay_tree_lookup (action_list->tree, (splay_tree_key)&a);
|
|
|
++ if (node)
|
|
|
++ return (text_action *)node->value;
|
|
|
+ }
|
|
|
+ return NULL;
|
|
|
+ }
|
|
|
+@@ -5784,40 +5826,50 @@ find_insn_action (text_action_list *action_list, bfd_vma offset)
|
|
|
+ #if DEBUG
|
|
|
+
|
|
|
+ static void
|
|
|
+-print_action_list (FILE *fp, text_action_list *action_list)
|
|
|
++print_action (FILE *fp, text_action *r)
|
|
|
++{
|
|
|
++ const char *t = "unknown";
|
|
|
++ switch (r->action)
|
|
|
++ {
|
|
|
++ case ta_remove_insn:
|
|
|
++ t = "remove_insn"; break;
|
|
|
++ case ta_remove_longcall:
|
|
|
++ t = "remove_longcall"; break;
|
|
|
++ case ta_convert_longcall:
|
|
|
++ t = "convert_longcall"; break;
|
|
|
++ case ta_narrow_insn:
|
|
|
++ t = "narrow_insn"; break;
|
|
|
++ case ta_widen_insn:
|
|
|
++ t = "widen_insn"; break;
|
|
|
++ case ta_fill:
|
|
|
++ t = "fill"; break;
|
|
|
++ case ta_none:
|
|
|
++ t = "none"; break;
|
|
|
++ case ta_remove_literal:
|
|
|
++ t = "remove_literal"; break;
|
|
|
++ case ta_add_literal:
|
|
|
++ t = "add_literal"; break;
|
|
|
++ }
|
|
|
++
|
|
|
++ fprintf (fp, "%s: %s[0x%lx] \"%s\" %d\n",
|
|
|
++ r->sec->owner->filename,
|
|
|
++ r->sec->name, (unsigned long) r->offset, t, r->removed_bytes);
|
|
|
++}
|
|
|
++
|
|
|
++static int
|
|
|
++print_action_list_fn (splay_tree_node node, void *p)
|
|
|
+ {
|
|
|
+- text_action *r;
|
|
|
++ text_action *r = (text_action *)node->value;
|
|
|
+
|
|
|
+- fprintf (fp, "Text Action\n");
|
|
|
+- for (r = action_list->head; r != NULL; r = r->next)
|
|
|
+- {
|
|
|
+- const char *t = "unknown";
|
|
|
+- switch (r->action)
|
|
|
+- {
|
|
|
+- case ta_remove_insn:
|
|
|
+- t = "remove_insn"; break;
|
|
|
+- case ta_remove_longcall:
|
|
|
+- t = "remove_longcall"; break;
|
|
|
+- case ta_convert_longcall:
|
|
|
+- t = "convert_longcall"; break;
|
|
|
+- case ta_narrow_insn:
|
|
|
+- t = "narrow_insn"; break;
|
|
|
+- case ta_widen_insn:
|
|
|
+- t = "widen_insn"; break;
|
|
|
+- case ta_fill:
|
|
|
+- t = "fill"; break;
|
|
|
+- case ta_none:
|
|
|
+- t = "none"; break;
|
|
|
+- case ta_remove_literal:
|
|
|
+- t = "remove_literal"; break;
|
|
|
+- case ta_add_literal:
|
|
|
+- t = "add_literal"; break;
|
|
|
+- }
|
|
|
++ print_action (p, r);
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+
|
|
|
+- fprintf (fp, "%s: %s[0x%lx] \"%s\" %d\n",
|
|
|
+- r->sec->owner->filename,
|
|
|
+- r->sec->name, (unsigned long) r->offset, t, r->removed_bytes);
|
|
|
+- }
|
|
|
++static void
|
|
|
++print_action_list (FILE *fp, text_action_list *action_list)
|
|
|
++{
|
|
|
++ fprintf (fp, "Text Action\n");
|
|
|
++ splay_tree_foreach (action_list->tree, print_action_list_fn, fp);
|
|
|
+ }
|
|
|
+
|
|
|
+ #endif /* DEBUG */
|
|
|
+@@ -6071,8 +6123,8 @@ init_xtensa_relax_info (asection *sec)
|
|
|
+ relax_info->removed_list.head = NULL;
|
|
|
+ relax_info->removed_list.tail = NULL;
|
|
|
+
|
|
|
+- relax_info->action_list.head = NULL;
|
|
|
+-
|
|
|
++ relax_info->action_list.tree = splay_tree_new (text_action_compare,
|
|
|
++ NULL, NULL);
|
|
|
+ relax_info->action_list.map.n_entries = 0;
|
|
|
+ relax_info->action_list.map.entry = NULL;
|
|
|
+
|
|
|
+@@ -7762,7 +7814,7 @@ compute_text_actions (bfd *abfd,
|
|
|
+ free_reloc_range_list (&relevant_relocs);
|
|
|
+
|
|
|
+ #if DEBUG
|
|
|
+- if (relax_info->action_list.head)
|
|
|
++ if (action_list_count (&relax_info->action_list))
|
|
|
+ print_action_list (stderr, &relax_info->action_list);
|
|
|
+ #endif
|
|
|
+
|
|
|
+@@ -8263,6 +8315,54 @@ xlate_offset_with_removed_text (const xlate_map_t *map,
|
|
|
+ return e->new_address - e->orig_address + offset;
|
|
|
+ }
|
|
|
+
|
|
|
++typedef struct xlate_map_context_struct xlate_map_context;
|
|
|
++struct xlate_map_context_struct
|
|
|
++{
|
|
|
++ xlate_map_t *map;
|
|
|
++ xlate_map_entry_t *current_entry;
|
|
|
++ int removed;
|
|
|
++};
|
|
|
++
|
|
|
++static int
|
|
|
++xlate_map_fn (splay_tree_node node, void *p)
|
|
|
++{
|
|
|
++ text_action *r = (text_action *)node->value;
|
|
|
++ xlate_map_context *ctx = p;
|
|
|
++ unsigned orig_size = 0;
|
|
|
++
|
|
|
++ switch (r->action)
|
|
|
++ {
|
|
|
++ case ta_none:
|
|
|
++ case ta_remove_insn:
|
|
|
++ case ta_convert_longcall:
|
|
|
++ case ta_remove_literal:
|
|
|
++ case ta_add_literal:
|
|
|
++ break;
|
|
|
++ case ta_remove_longcall:
|
|
|
++ orig_size = 6;
|
|
|
++ break;
|
|
|
++ case ta_narrow_insn:
|
|
|
++ orig_size = 3;
|
|
|
++ break;
|
|
|
++ case ta_widen_insn:
|
|
|
++ orig_size = 2;
|
|
|
++ break;
|
|
|
++ case ta_fill:
|
|
|
++ break;
|
|
|
++ }
|
|
|
++ ctx->current_entry->size =
|
|
|
++ r->offset + orig_size - ctx->current_entry->orig_address;
|
|
|
++ if (ctx->current_entry->size != 0)
|
|
|
++ {
|
|
|
++ ctx->current_entry++;
|
|
|
++ ctx->map->entry_count++;
|
|
|
++ }
|
|
|
++ ctx->current_entry->orig_address = r->offset + orig_size;
|
|
|
++ ctx->removed += r->removed_bytes;
|
|
|
++ ctx->current_entry->new_address = r->offset + orig_size - ctx->removed;
|
|
|
++ ctx->current_entry->size = 0;
|
|
|
++ return 0;
|
|
|
++}
|
|
|
+
|
|
|
+ /* Build a binary searchable offset translation map from a section's
|
|
|
+ action list. */
|
|
|
+@@ -8270,75 +8370,40 @@ xlate_offset_with_removed_text (const xlate_map_t *map,
|
|
|
+ static xlate_map_t *
|
|
|
+ build_xlate_map (asection *sec, xtensa_relax_info *relax_info)
|
|
|
+ {
|
|
|
+- xlate_map_t *map = (xlate_map_t *) bfd_malloc (sizeof (xlate_map_t));
|
|
|
+ text_action_list *action_list = &relax_info->action_list;
|
|
|
+ unsigned num_actions = 0;
|
|
|
+- text_action *r;
|
|
|
+- int removed;
|
|
|
+- xlate_map_entry_t *current_entry;
|
|
|
++ xlate_map_context ctx;
|
|
|
+
|
|
|
+- if (map == NULL)
|
|
|
++ ctx.map = (xlate_map_t *) bfd_malloc (sizeof (xlate_map_t));
|
|
|
++
|
|
|
++ if (ctx.map == NULL)
|
|
|
+ return NULL;
|
|
|
+
|
|
|
+ num_actions = action_list_count (action_list);
|
|
|
+- map->entry = (xlate_map_entry_t *)
|
|
|
++ ctx.map->entry = (xlate_map_entry_t *)
|
|
|
+ bfd_malloc (sizeof (xlate_map_entry_t) * (num_actions + 1));
|
|
|
+- if (map->entry == NULL)
|
|
|
++ if (ctx.map->entry == NULL)
|
|
|
+ {
|
|
|
+- free (map);
|
|
|
++ free (ctx.map);
|
|
|
+ return NULL;
|
|
|
+ }
|
|
|
+- map->entry_count = 0;
|
|
|
++ ctx.map->entry_count = 0;
|
|
|
+
|
|
|
+- removed = 0;
|
|
|
+- current_entry = &map->entry[0];
|
|
|
++ ctx.removed = 0;
|
|
|
++ ctx.current_entry = &ctx.map->entry[0];
|
|
|
+
|
|
|
+- current_entry->orig_address = 0;
|
|
|
+- current_entry->new_address = 0;
|
|
|
+- current_entry->size = 0;
|
|
|
++ ctx.current_entry->orig_address = 0;
|
|
|
++ ctx.current_entry->new_address = 0;
|
|
|
++ ctx.current_entry->size = 0;
|
|
|
+
|
|
|
+- for (r = action_list->head; r != NULL; r = r->next)
|
|
|
+- {
|
|
|
+- unsigned orig_size = 0;
|
|
|
+- switch (r->action)
|
|
|
+- {
|
|
|
+- case ta_none:
|
|
|
+- case ta_remove_insn:
|
|
|
+- case ta_convert_longcall:
|
|
|
+- case ta_remove_literal:
|
|
|
+- case ta_add_literal:
|
|
|
+- break;
|
|
|
+- case ta_remove_longcall:
|
|
|
+- orig_size = 6;
|
|
|
+- break;
|
|
|
+- case ta_narrow_insn:
|
|
|
+- orig_size = 3;
|
|
|
+- break;
|
|
|
+- case ta_widen_insn:
|
|
|
+- orig_size = 2;
|
|
|
+- break;
|
|
|
+- case ta_fill:
|
|
|
+- break;
|
|
|
+- }
|
|
|
+- current_entry->size =
|
|
|
+- r->offset + orig_size - current_entry->orig_address;
|
|
|
+- if (current_entry->size != 0)
|
|
|
+- {
|
|
|
+- current_entry++;
|
|
|
+- map->entry_count++;
|
|
|
+- }
|
|
|
+- current_entry->orig_address = r->offset + orig_size;
|
|
|
+- removed += r->removed_bytes;
|
|
|
+- current_entry->new_address = r->offset + orig_size - removed;
|
|
|
+- current_entry->size = 0;
|
|
|
+- }
|
|
|
++ splay_tree_foreach (action_list->tree, xlate_map_fn, &ctx);
|
|
|
+
|
|
|
+- current_entry->size = (bfd_get_section_limit (sec->owner, sec)
|
|
|
+- - current_entry->orig_address);
|
|
|
+- if (current_entry->size != 0)
|
|
|
+- map->entry_count++;
|
|
|
++ ctx.current_entry->size = (bfd_get_section_limit (sec->owner, sec)
|
|
|
++ - ctx.current_entry->orig_address);
|
|
|
++ if (ctx.current_entry->size != 0)
|
|
|
++ ctx.map->entry_count++;
|
|
|
+
|
|
|
+- return map;
|
|
|
++ return ctx.map;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+@@ -9302,6 +9367,16 @@ move_shared_literal (asection *sec,
|
|
|
+
|
|
|
+ /* Second relaxation pass. */
|
|
|
+
|
|
|
++static int
|
|
|
++action_remove_bytes_fn (splay_tree_node node, void *p)
|
|
|
++{
|
|
|
++ bfd_size_type *final_size = p;
|
|
|
++ text_action *action = (text_action *)node->value;
|
|
|
++
|
|
|
++ *final_size -= action->removed_bytes;
|
|
|
++ return 0;
|
|
|
++}
|
|
|
++
|
|
|
+ /* Modify all of the relocations to point to the right spot, and if this
|
|
|
+ is a relaxable section, delete the unwanted literals and fix the
|
|
|
+ section size. */
|
|
|
+@@ -9334,7 +9409,7 @@ relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
|
|
|
+
|
|
|
+ internal_relocs = retrieve_internal_relocs (abfd, sec,
|
|
|
+ link_info->keep_memory);
|
|
|
+- if (!internal_relocs && !relax_info->action_list.head)
|
|
|
++ if (!internal_relocs && !action_list_count (&relax_info->action_list))
|
|
|
+ return TRUE;
|
|
|
+
|
|
|
+ contents = retrieve_contents (abfd, sec, link_info->keep_memory);
|
|
|
+@@ -9412,6 +9487,12 @@ relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
|
|
|
+ }
|
|
|
+ /* Update the action so that the code that moves
|
|
|
+ the contents will do the right thing. */
|
|
|
++ /* ta_remove_longcall and ta_remove_insn actions are
|
|
|
++ grouped together in the tree as well as
|
|
|
++ ta_convert_longcall and ta_none, so that changes below
|
|
|
++ can be done w/o removing and reinserting action into
|
|
|
++ the tree. */
|
|
|
++
|
|
|
+ if (action->action == ta_remove_longcall)
|
|
|
+ action->action = ta_remove_insn;
|
|
|
+ else
|
|
|
+@@ -9584,13 +9665,12 @@ relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
|
|
|
+
|
|
|
+ if ((relax_info->is_relaxable_literal_section
|
|
|
+ || relax_info->is_relaxable_asm_section)
|
|
|
+- && relax_info->action_list.head)
|
|
|
++ && action_list_count (&relax_info->action_list))
|
|
|
+ {
|
|
|
+ /* Walk through the planned actions and build up a table
|
|
|
+ of move, copy and fill records. Use the move, copy and
|
|
|
+ fill records to perform the actions once. */
|
|
|
+
|
|
|
+- int removed = 0;
|
|
|
+ bfd_size_type final_size, copy_size, orig_insn_size;
|
|
|
+ bfd_byte *scratch = NULL;
|
|
|
+ bfd_byte *dup_contents = NULL;
|
|
|
+@@ -9601,15 +9681,12 @@ relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
|
|
|
+ bfd_vma orig_dot_vo = 0; /* Virtual offset from orig_dot. */
|
|
|
+ bfd_vma dup_dot = 0;
|
|
|
+
|
|
|
+- text_action *action = relax_info->action_list.head;
|
|
|
++ text_action *action;
|
|
|
+
|
|
|
+ final_size = sec->size;
|
|
|
+- for (action = relax_info->action_list.head; action;
|
|
|
+- action = action->next)
|
|
|
+- {
|
|
|
+- final_size -= action->removed_bytes;
|
|
|
+- }
|
|
|
+
|
|
|
++ splay_tree_foreach (relax_info->action_list.tree,
|
|
|
++ action_remove_bytes_fn, &final_size);
|
|
|
+ scratch = (bfd_byte *) bfd_zmalloc (final_size);
|
|
|
+ dup_contents = (bfd_byte *) bfd_zmalloc (final_size);
|
|
|
+
|
|
|
+@@ -9618,8 +9695,8 @@ relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
|
|
|
+ print_action_list (stderr, &relax_info->action_list);
|
|
|
+ #endif
|
|
|
+
|
|
|
+- for (action = relax_info->action_list.head; action;
|
|
|
+- action = action->next)
|
|
|
++ for (action = action_first (&relax_info->action_list); action;
|
|
|
++ action = action_next (&relax_info->action_list, action))
|
|
|
+ {
|
|
|
+ virtual_action = FALSE;
|
|
|
+ if (action->offset > orig_dot)
|
|
|
+@@ -9748,7 +9825,6 @@ relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+- removed += action->removed_bytes;
|
|
|
+ BFD_ASSERT (dup_dot <= final_size);
|
|
|
+ BFD_ASSERT (orig_dot <= orig_size);
|
|
|
+ }
|
|
|
+--
|
|
|
+1.8.1.4
|
|
|
+
|
Max Filippov