+/* Given SELECTED, a currently selected BFD architecture, and
+ TARGET_DESC, the current target description, return what
+ architecture to use.
+
+ SELECTED may be NULL, in which case we return the architecture
+ associated with TARGET_DESC. If SELECTED specifies a variant
+ of the architecture associtated with TARGET_DESC, return the
+ more specific of the two.
+
+ If SELECTED is a different architecture, but it is accepted as
+ compatible by the target, we can use the target architecture.
+
+ If SELECTED is obviously incompatible, warn the user. */
+
+static const struct bfd_arch_info *
+choose_architecture_for_target (const struct target_desc *target_desc,
+ const struct bfd_arch_info *selected)
+{
+ const struct bfd_arch_info *from_target = tdesc_architecture (target_desc);
+ const struct bfd_arch_info *compat1, *compat2;
+
+ if (selected == NULL)
+ return from_target;
+
+ if (from_target == NULL)
+ return selected;
+
+ /* struct bfd_arch_info objects are singletons: that is, there's
+ supposed to be exactly one instance for a given machine. So you
+ can tell whether two are equivalent by comparing pointers. */
+ if (from_target == selected)
+ return selected;
+
+ /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
+ incompatible. But if they are compatible, it returns the 'more
+ featureful' of the two arches. That is, if A can run code
+ written for B, but B can't run code written for A, then it'll
+ return A.
+
+ Some targets (e.g. MIPS as of 2006-12-04) don't fully
+ implement this, instead always returning NULL or the first
+ argument. We detect that case by checking both directions. */
+
+ compat1 = selected->compatible (selected, from_target);
+ compat2 = from_target->compatible (from_target, selected);
+
+ if (compat1 == NULL && compat2 == NULL)
+ {
+ /* BFD considers the architectures incompatible. Check our
+ target description whether it accepts SELECTED as compatible
+ anyway. */
+ if (tdesc_compatible_p (target_desc, selected))
+ return from_target;
+
+ warning (_("Selected architecture %s is not compatible "
+ "with reported target architecture %s"),
+ selected->printable_name, from_target->printable_name);
+ return selected;
+ }
+
+ if (compat1 == NULL)
+ return compat2;
+ if (compat2 == NULL)
+ return compat1;
+ if (compat1 == compat2)
+ return compat1;
+
+ /* If the two didn't match, but one of them was a default
+ architecture, assume the more specific one is correct. This
+ handles the case where an executable or target description just
+ says "mips", but the other knows which MIPS variant. */
+ if (compat1->the_default)
+ return compat2;
+ if (compat2->the_default)
+ return compat1;
+
+ /* We have no idea which one is better. This is a bug, but not
+ a critical problem; warn the user. */
+ warning (_("Selected architecture %s is ambiguous with "
+ "reported target architecture %s"),
+ selected->printable_name, from_target->printable_name);
+ return selected;
+}
+
+/* Functions to manipulate the architecture of the target. */