Recompute ArchSpec core after MergeFrom

[labath]

Summary

MergeFrom was updating the architecture if the target triple did not
have it set. However, it was leaving the core field as invalid. This
resulted in assertion failures in core file tests as a missing core
meant we were unable to compute the address byte size properly.

Add a unit test for the new behaviour.

[labath]

Also remove the skipIfDarwin decorators, as they should work now -- there was
nothing darwin-specific about them, just our bots don't run assert builds at the
moment.

include/lldb/Core/ArchSpec.h

public:
   uint32_t GetFlags() const { return m_flags; }
 
   void SetFlags(uint32_t flags) { m_flags = flags; }
 
   void SetFlags(std::string elf_abi);
 
 protected:
   bool IsEqualTo(const ArchSpec &rhs, bool exact_match) const;
+  void UpdateCore();
 
   llvm::Triple m_triple;
   Core m_core = kCore_invalid;
   lldb::ByteOrder m_byte_order = lldb::eByteOrderInvalid;
 
   // Additional arch flags which we cannot get from triple and core
   // For MIPS these are application specific extensions like
   // micromips, mips16 etc.

source/Core/ArchSpec.cpp

lldb::ByteOrder ArchSpec::GetByteOrder() const {
   return m_byte_order;
 }
 
 //===----------------------------------------------------------------------===//
 // Mutators.
 
 bool ArchSpec::SetTriple(const llvm::Triple &triple) {
   m_triple = triple;
-
-  llvm::StringRef arch_name(m_triple.getArchName());
-  const CoreDefinition *core_def = FindCoreDefinition(arch_name);
-  if (core_def) {
-    m_core = core_def->core;
-    // Set the byte order to the default byte order for an architecture.
-    // This can be modified if needed for cases when cores handle both
-    // big and little endian
-    m_byte_order = core_def->default_byte_order;
-  } else {
-    Clear();
-  }
-
+  UpdateCore();
   return IsValid();
 }
 
 bool lldb_private::ParseMachCPUDashSubtypeTriple(llvm::StringRef triple_str,
                                                  ArchSpec &arch) {
   // Accept "12-10" or "12.10" as cpu type/subtype
   if (triple_str.empty())
     return false;

 }
 
 void ArchSpec::MergeFrom(const ArchSpec &other) {
   if (TripleVendorIsUnspecifiedUnknown() &&
       !other.TripleVendorIsUnspecifiedUnknown())
     GetTriple().setVendor(other.GetTriple().getVendor());
   if (TripleOSIsUnspecifiedUnknown() && !other.TripleOSIsUnspecifiedUnknown())
     GetTriple().setOS(other.GetTriple().getOS());
-  if (GetTriple().getArch() == llvm::Triple::UnknownArch)
+  if (GetTriple().getArch() == llvm::Triple::UnknownArch) {
     GetTriple().setArch(other.GetTriple().getArch());
+    UpdateCore();
+  }
   if (GetTriple().getEnvironment() == llvm::Triple::UnknownEnvironment &&
       !TripleVendorWasSpecified()) {
     if (other.TripleVendorWasSpecified())
       GetTriple().setEnvironment(other.GetTriple().getEnvironment());
   }
   // If this and other are both arm ArchSpecs and this ArchSpec is a generic
   // "some kind of arm"
   // spec but the other ArchSpec is a specific arm core, adopt the specific arm
if (core_match) {
 
     if (!isCompatibleEnvironment(lhs_triple_env, rhs_triple_env))
       return false;
     return true;
   }
   return false;
 }
 
+void ArchSpec::UpdateCore() {
+  llvm::StringRef arch_name(m_triple.getArchName());
+  const CoreDefinition *core_def = FindCoreDefinition(arch_name);
+  if (core_def) {
+    m_core = core_def->core;
+    // Set the byte order to the default byte order for an architecture.
+    // This can be modified if needed for cases when cores handle both
+    // big and little endian
+    m_byte_order = core_def->default_byte_order;
+  } else {
+    Clear();
+  }
+}
+
 //===----------------------------------------------------------------------===//
 // Helper methods.
 
 void ArchSpec::CoreUpdated(bool update_triple) {
   const CoreDefinition *core_def = FindCoreDefinition(m_core);
   if (core_def) {
     if (update_triple)
       m_triple = llvm::Triple(core_def->name, "unknown", "unknown");

unittests/Core/ArchSpecTest.cpp

TEST(ArchSpecTest, TestSetTriple) {
   EXPECT_FALSE(AS.SetTriple("unknown-unknown-unknown"));
 
   AS = ArchSpec();
   EXPECT_FALSE(AS.SetTriple("unknown"));
 
   AS = ArchSpec();
   EXPECT_FALSE(AS.SetTriple(""));
 }
+
+TEST(ArchSpecTest, MergeFrom) {
+  ArchSpec A;
+  ArchSpec B("x86_64-pc-linux");
+
+  EXPECT_FALSE(A.IsValid());
+  ASSERT_TRUE(B.IsValid());
+  EXPECT_EQ(llvm::Triple::ArchType::x86_64, B.GetTriple().getArch());
+  EXPECT_EQ(llvm::Triple::VendorType::PC, B.GetTriple().getVendor());
+  EXPECT_EQ(llvm::Triple::OSType::Linux, B.GetTriple().getOS());
+  EXPECT_EQ(ArchSpec::eCore_x86_64_x86_64, B.GetCore());
+
+  A.MergeFrom(B);
+  ASSERT_TRUE(A.IsValid());
+  EXPECT_EQ(llvm::Triple::ArchType::x86_64, A.GetTriple().getArch());
+  EXPECT_EQ(llvm::Triple::VendorType::PC, A.GetTriple().getVendor());
+  EXPECT_EQ(llvm::Triple::OSType::Linux, A.GetTriple().getOS());
+  EXPECT_EQ(ArchSpec::eCore_x86_64_x86_64, A.GetCore());
+}